(Wolfgang Bangerth, 2012/08/06)
<li> Changed: The argument material_id of the estimate-functions of
-the KellyErrorEstimator class is now of type types::material_id_type
+the KellyErrorEstimator class is now of type types::material_id
with default value types::invalid_material_id, instead of type
unsigned int with default value numbers::invalid_unsigned_int. This
should not make a difference to most users unless you specified the
<li>
The member functions Triangulation::set_boundary and
-Triangulation::get_boundary now take a types::boundary_id_t instead of
+Triangulation::get_boundary now take a types::boundary_id instead of
an unsigned int as argument. This now matches the actual data type
used to store boundary indicators internally.
<br>
<ol>
<li>
-Changed: unify the concept of compress() for all linear algebra
+Changed: To make the naming of types defined in namespace types
+consistent, we have renamed types::subdomain_id_t to
+types::subdomain_id. The old name has been retained as a typedef
+but is now deprecated.
+<br>
+(Wolfgang Bangerth, 2012/08/22)
+
+<li>
+Changed: Unify the concept of compress() for all linear algebra
objects. Introduce type VectorOperation to decide between
add and insert. Implement also for serial vectors. Note:
-this breaks distributed::vector::compress(bool).
+this breaks distributed::vector::compress(bool). See
+@ref GlossCompress for more information.
<br>
(Timo Heister, 2012/08/13)
<li> Changed: Material and Boundary indicators have been both of the
type unsigned char. Throughout the library, we changed their datatype
-to <code>types::material_id_t</code>
-resp. <code>types::boundary_id_t</code>, both typedefs of unsigned
+to <code>types::material_id</code>
+resp. <code>types::boundary_id</code>, both typedefs of unsigned
char. Internal faces are now characterized by
-types::internal_face_boundary_id(<code>=static_cast@<boundary_id_t@>(-1)</code>)
+types::internal_face_boundary_id(<code>=static_cast@<types::boundary_id@>(-1)</code>)
instead of 255, so we get rid of that mysterious number in the source
code. Material_ids are also assumed to lie in the range from 0 to
types::invalid_material_id-1 (where <code>types::invalid_material_id =
-static_cast<material_id_t>(-1)</code>). With this change, it is now
+static_cast<types::material_id>(-1)</code>). With this change, it is now
much easier to extend the range of boundary or material ids, if
needed.
<br>
stokes_constraints.clear ();
DoFTools::make_hanging_node_constraints (stokes_dof_handler,
stokes_constraints);
- std::set<types::boundary_id_t> no_normal_flux_boundaries;
+ std::set<types::boundary_id> no_normal_flux_boundaries;
no_normal_flux_boundaries.insert (0);
VectorTools::compute_no_normal_flux_constraints (stokes_dof_handler, 0,
no_normal_flux_boundaries,
stokes_constraints,
velocity_mask);
- std::set<types::boundary_id_t> no_normal_flux_boundaries;
+ std::set<types::boundary_id> no_normal_flux_boundaries;
no_normal_flux_boundaries.insert (1);
VectorTools::compute_no_normal_flux_constraints (stokes_dof_handler, 0,
no_normal_flux_boundaries,
EquationData::Velocity<dim> vel_exact;
std::map<unsigned int, double> boundary_values;
- std::vector<types::boundary_id_t> boundary_indicators;
+ std::vector<types::boundary_id> boundary_indicators;
Triangulation<dim> triangulation;
vel_exact.set_component(d);
boundary_values.clear();
- for (std::vector<types::boundary_id_t>::const_iterator
+ for (std::vector<types::boundary_id>::const_iterator
boundaries = boundary_indicators.begin();
boundaries != boundary_indicators.end();
++boundaries)
Triangulation<spacedim> volume_mesh;
GridGenerator::half_hyper_ball(volume_mesh);
- std::set<types::boundary_id_t> boundary_ids;
+ std::set<types::boundary_id> boundary_ids;
boundary_ids.insert (0);
GridTools::extract_boundary_mesh (volume_mesh, triangulation,
* See the @ref GlossSubdomainId
* "glossary" for more information.
*/
- typedef unsigned int subdomain_id_t;
+ typedef unsigned int subdomain_id;
/**
* A special id for an invalid
* See the @ref GlossSubdomainId
* "glossary" for more information.
*/
- const unsigned int invalid_subdomain_id = static_cast<subdomain_id_t>(-1);
+ const unsigned int invalid_subdomain_id = static_cast<subdomain_id>(-1);
/**
* The subdomain id assigned to a
* the @ref distributed module for
* more information.
*/
- const unsigned int artificial_subdomain_id = static_cast<subdomain_id_t>(-2);
+ const unsigned int artificial_subdomain_id = static_cast<subdomain_id>(-2);
/**
* The type used to denote global dof
* piece of the boundary and, in the case of meshes that describe
* manifolds in higher dimensions, associated with every cell.
*/
- typedef unsigned char boundary_id_t;
+ typedef unsigned char boundary_id;
/**
* The number which we reserve for internal faces.
* We assume that all boundary_ids lie in the range [0, internal_face_boundary_id).
*/
- const boundary_id_t internal_face_boundary_id = static_cast<boundary_id_t>(-1);
+ const boundary_id internal_face_boundary_id = static_cast<boundary_id>(-1);
/**
* The type used to denote material indicators associated with every
* cell.
*/
- typedef unsigned char material_id_t;
+ typedef unsigned char material_id;
/**
* Invalid material_id which we need in several places as a default value.
* We assume that all material_ids lie in the range [0, invalid_material_id).
*/
- const material_id_t invalid_material_id = static_cast<material_id_t>(-1);
+ const material_id invalid_material_id = static_cast<material_id>(-1);
}
* children that only exist
* on other processors.
*/
- types::subdomain_id_t locally_owned_subdomain () const;
+ types::subdomain_id locally_owned_subdomain () const;
/**
* Return the number of
* used for the current
* processor.
*/
- types::subdomain_id_t my_subdomain;
+ types::subdomain_id my_subdomain;
/**
* A flag that indicates whether the
* children that only exist
* on other processors.
*/
- types::subdomain_id_t locally_owned_subdomain () const;
+ types::subdomain_id locally_owned_subdomain () const;
/**
* Dummy arrays. This class
* children that only exist
* on other processors.
*/
- types::subdomain_id_t locally_owned_subdomain () const;
+ types::subdomain_id locally_owned_subdomain () const;
/**
* Return the MPI
* consideration.
*/
unsigned int
- n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const;
+ n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const;
/**
* Access to an object informing
template <> unsigned int DoFHandler<1>::n_boundary_dofs () const;
template <> unsigned int DoFHandler<1>::n_boundary_dofs (const FunctionMap &) const;
-template <> unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id_t> &) const;
+template <> unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &) const;
/* ----------------------- Inline functions ---------------------------------- */
SparsityPattern &sparsity_pattern,
const ConstraintMatrix &constraints = ConstraintMatrix(),
const bool keep_constrained_dofs = true,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id);
/**
* Locate non-zero entries for
SparsityPattern &sparsity_pattern,
const ConstraintMatrix &constraints = ConstraintMatrix(),
const bool keep_constrained_dofs = true,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id);
/**
* @deprecated This is the old
SparsityPattern &sparsity_pattern,
const ConstraintMatrix &constraints,
const bool keep_constrained_dofs = true,
- const types::subdomain_id_t subdomain_id = numbers::invalid_unsigned_int);
+ const types::subdomain_id subdomain_id = numbers::invalid_unsigned_int);
/**
* This function does the same as
template<typename DH>
void
make_periodicity_constraints (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const int direction,
dealii::ConstraintMatrix &constraint_matrix,
const std::vector<bool> &component_mask = std::vector<bool>());
template<typename DH>
void
make_periodicity_constraints (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const int direction,
dealii::Tensor<1,DH::space_dimension>
&offset,
extract_boundary_dofs (const DH &dof_handler,
const std::vector<bool> &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* This function does the same as the previous one but it
extract_boundary_dofs (const DH &dof_handler,
const std::vector<bool> &component_mask,
IndexSet &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* This function is similar to
extract_dofs_with_support_on_boundary (const DH &dof_handler,
const std::vector<bool> &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* @name Hanging Nodes
template <class DH>
void
extract_subdomain_dofs (const DH &dof_handler,
- const types::subdomain_id_t subdomain_id,
+ const types::subdomain_id subdomain_id,
std::vector<bool> &selected_dofs);
template <class DH>
void
get_subdomain_association (const DH &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain);
+ std::vector<types::subdomain_id> &subdomain);
/**
* Count how many degrees of freedom are
template <class DH>
unsigned int
count_dofs_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain);
+ const types::subdomain_id subdomain);
/**
* Count how many degrees of freedom are
template <class DH>
void
count_dofs_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain,
+ const types::subdomain_id subdomain,
std::vector<unsigned int> &n_dofs_on_subdomain);
/**
template <class DH>
IndexSet
dof_indices_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain);
+ const types::subdomain_id subdomain);
// @}
/**
template <class DH>
void
map_dof_to_boundary_indices (const DH &dof_handler,
- const std::set<types::boundary_id_t> &boundary_indicators,
+ const std::set<types::boundary_id> &boundary_indicators,
std::vector<unsigned int> &mapping);
/**
* name it in the fashion of the
* STL local typedefs.
*/
- typedef std::map<types::boundary_id_t, const Function<dim>*> type;
+ typedef std::map<types::boundary_id, const Function<dim>*> type;
};
DEAL_II_NAMESPACE_CLOSE
* shall have to be evaluated
* to true.
*/
- SubdomainEqualTo (const types::subdomain_id_t subdomain_id);
+ SubdomainEqualTo (const types::subdomain_id subdomain_id);
/**
* Evaluation operator. Returns
* Stored value to compare the
* subdomain with.
*/
- const types::subdomain_id_t subdomain_id;
+ const types::subdomain_id subdomain_id;
};
* class SubdomainEqualTo
* {
* public:
- * SubdomainEqualTo (const types::subdomain_id_t subdomain_id)
+ * SubdomainEqualTo (const types::subdomain_id subdomain_id)
* : subdomain_id (subdomain_id) {};
*
* template <class Iterator>
* }
*
* private:
- * const types::subdomain_id_t subdomain_id;
+ * const types::subdomain_id subdomain_id;
* };
* @endcode
* Objects like <code>SubdomainEqualTo(3)</code> can then be used as predicates.
// ---------------- IteratorFilters::SubdomainEqualTo ---------
inline
- SubdomainEqualTo::SubdomainEqualTo (const types::subdomain_id_t subdomain_id)
+ SubdomainEqualTo::SubdomainEqualTo (const types::subdomain_id subdomain_id)
:
subdomain_id (subdomain_id)
{}
subdivided_hyper_rectangle (Triangulation<dim> &tria,
const std::vector< std::vector<double> > &spacing,
const Point<dim> &p,
- const Table<dim,types::material_id_t> &material_id,
+ const Table<dim,types::material_id> &material_id,
const bool colorize=false);
/**
template <int dim, int spacedim>
void
get_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
- std::vector<types::subdomain_id_t> &subdomain);
+ std::vector<types::subdomain_id> &subdomain);
/**
* Count how many cells are uniquely
template <int dim, int spacedim>
unsigned int
count_cells_with_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
- const types::subdomain_id_t subdomain);
+ const types::subdomain_id subdomain);
/**
* Given two mesh containers
typename Container<dim,spacedim>::face_iterator>
extract_boundary_mesh (const Container<dim,spacedim> &volume_mesh,
Container<dim-1,spacedim> &surface_mesh,
- const std::set<types::boundary_id_t> &boundary_ids
- = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_ids
+ = std::set<types::boundary_id>());
/**
std::map<CellIterator, CellIterator>
collect_periodic_cell_pairs (const CellIterator &begin,
const typename identity<CellIterator>::type &end,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
int direction,
const dealii::Tensor<1,CellIterator::AccessorType::space_dimension>
&offset = dealii::Tensor<1,CellIterator::AccessorType::space_dimension>());
template<typename DH>
std::map<typename DH::cell_iterator, typename DH::cell_iterator>
collect_periodic_cell_pairs (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
int direction,
const dealii::Tensor<1,DH::space_dimension>
&offset = Tensor<1,DH::space_dimension>());
*/
union
{
- types::boundary_id_t boundary_id;
- types::material_id_t material_id;
+ types::boundary_id boundary_id;
+ types::material_id material_id;
};
};
* boundary, for instance the material id
* in a UCD input file. They are not
* necessarily consecutive but must be in
- * the range 0-(types::boundary_id_t-1).
+ * the range 0-(types::boundary_id-1).
* Material IDs on boundaries are also
* called boundary indicators and are
* accessed with accessor functions
*
* @ingroup boundary
*/
- void set_boundary (const types::boundary_id_t number,
+ void set_boundary (const types::boundary_id number,
const Boundary<dim,spacedim> &boundary_object);
/**
*
* @ingroup boundary
*/
- void set_boundary (const types::boundary_id_t number);
+ void set_boundary (const types::boundary_id number);
/**
* Return a constant reference to
*
* @ingroup boundary
*/
- const Boundary<dim,spacedim> & get_boundary (const types::boundary_id_t number) const;
+ const Boundary<dim,spacedim> & get_boundary (const types::boundary_id number) const;
/**
* Returns a vector containing
*
* @ingroup boundary
*/
- std::vector<types::boundary_id_t> get_boundary_indicators() const;
+ std::vector<types::boundary_id> get_boundary_indicators() const;
/**
* Copy a triangulation. This
* of those cells that are owned
* by the current processor.
*/
- virtual types::subdomain_id_t locally_owned_subdomain () const;
+ virtual types::subdomain_id locally_owned_subdomain () const;
/*@}*/
/**
* objects, which are not
* of type StraightBoundary.
*/
- std::map<types::boundary_id_t, SmartPointer<const Boundary<dim, spacedim> , Triangulation<dim, spacedim> > > boundary;
+ std::map<types::boundary_id, SmartPointer<const Boundary<dim, spacedim> , Triangulation<dim, spacedim> > > boundary;
/**
* Flag indicating whether
* TriaAccessor::set_boundary_indicator)
* were not a pointer.
*/
- std::map<unsigned int, types::boundary_id_t> *vertex_to_boundary_id_map_1d;
+ std::map<unsigned int, types::boundary_id> *vertex_to_boundary_id_map_1d;
/**
* A map that correlates each refinement listener that has been added
* then this object is in the
* interior of the domain.
*/
- types::boundary_id_t boundary_indicator () const;
+ types::boundary_id boundary_indicator () const;
/**
* Set the boundary indicator.
*
* @ingroup boundary
*/
- void set_boundary_indicator (const types::boundary_id_t) const;
+ void set_boundary_indicator (const types::boundary_id) const;
/**
* Do as set_boundary_indicator()
*
* @ingroup boundary
*/
- void set_all_boundary_indicators (const types::boundary_id_t) const;
+ void set_all_boundary_indicators (const types::boundary_id) const;
/**
* Return whether this object is at the
* then this object is in the
* interior of the domain.
*/
- types::boundary_id_t boundary_indicator () const;
+ types::boundary_id boundary_indicator () const;
/**
* @name Orientation of sub-objects
* @ingroup boundary
*/
void
- set_boundary_indicator (const types::boundary_id_t);
+ set_boundary_indicator (const types::boundary_id);
/**
* Since this object only represents a
* @ingroup boundary
*/
void
- set_all_boundary_indicators (const types::boundary_id_t);
+ set_all_boundary_indicators (const types::boundary_id);
/**
* @}
*/
* "glossary" for more
* information.
*/
- types::material_id_t material_id () const;
+ types::material_id material_id () const;
/**
* Set the material id of this
* "glossary" for more
* information.
*/
- void set_material_id (const types::material_id_t new_material_id) const;
+ void set_material_id (const types::material_id new_material_id) const;
/**
* Set the material id of this
* "glossary" for more
* information.
*/
- void recursively_set_material_id (const types::material_id_t new_material_id) const;
+ void recursively_set_material_id (const types::material_id new_material_id) const;
/**
* @}
*/
* parallel::distributed::Triangulation
* object.
*/
- types::subdomain_id_t subdomain_id () const;
+ types::subdomain_id subdomain_id () const;
/**
* Set the subdomain id of this
* parallel::distributed::Triangulation
* object.
*/
- void set_subdomain_id (const types::subdomain_id_t new_subdomain_id) const;
+ void set_subdomain_id (const types::subdomain_id new_subdomain_id) const;
/**
* Set the subdomain id of this
* parallel::distributed::Triangulation
* object.
*/
- void recursively_set_subdomain_id (const types::subdomain_id_t new_subdomain_id) const;
+ void recursively_set_subdomain_id (const types::subdomain_id new_subdomain_id) const;
/**
* @}
*/
template <int structdim, int dim, int spacedim>
-types::boundary_id_t
+types::boundary_id
TriaAccessor<structdim, dim, spacedim>::boundary_indicator () const
{
Assert (structdim<dim, ExcImpossibleInDim(dim));
template <int structdim, int dim, int spacedim>
void
TriaAccessor<structdim, dim, spacedim>::
-set_boundary_indicator (const types::boundary_id_t boundary_ind) const
+set_boundary_indicator (const types::boundary_id boundary_ind) const
{
Assert (structdim<dim, ExcImpossibleInDim(dim));
Assert (this->used(), TriaAccessorExceptions::ExcCellNotUsed());
template <int structdim, int dim, int spacedim>
void
TriaAccessor<structdim, dim, spacedim>::
-set_all_boundary_indicators (const types::boundary_id_t boundary_ind) const
+set_all_boundary_indicators (const types::boundary_id boundary_ind) const
{
set_boundary_indicator (boundary_ind);
template <int spacedim>
inline
-types::boundary_id_t
+types::boundary_id
TriaAccessor<0, 1, spacedim>::boundary_indicator () const
{
switch (vertex_kind)
template <int spacedim>
inline
void
-TriaAccessor<0, 1, spacedim>::set_boundary_indicator (const types::boundary_id_t b)
+TriaAccessor<0, 1, spacedim>::set_boundary_indicator (const types::boundary_id b)
{
Assert (tria->vertex_to_boundary_id_map_1d->find (this->vertex_index())
!= tria->vertex_to_boundary_id_map_1d->end(),
template <int spacedim>
inline
-void TriaAccessor<0, 1, spacedim>::set_all_boundary_indicators (const types::boundary_id_t b)
+void TriaAccessor<0, 1, spacedim>::set_all_boundary_indicators (const types::boundary_id b)
{
set_boundary_indicator (b);
}
#ifndef DEAL_II_USE_P4EST
return true;
#else
- const types::subdomain_id_t subdomain = this->subdomain_id();
+ const types::subdomain_id subdomain = this->subdomain_id();
if (subdomain == types::artificial_subdomain_id)
return false;
#ifndef DEAL_II_USE_P4EST
return false;
#else
- const types::subdomain_id_t subdomain = this->subdomain_id();
+ const types::subdomain_id subdomain = this->subdomain_id();
if (subdomain == types::artificial_subdomain_id)
return false;
* cells with a given subdomain
* number.
*/
- std::vector<types::subdomain_id_t> subdomain_ids;
+ std::vector<types::subdomain_id> subdomain_ids;
/**
* One integer for every consecutive
std::vector<unsigned char> refine_flags;
std::vector<bool> coarsen_flags;
std::vector<std::pair<int,int> > neighbors;
- std::vector<types::subdomain_id_t> subdomain_ids;
+ std::vector<types::subdomain_id> subdomain_ids;
std::vector<int> parents;
// The following is not used
{
union
{
- types::boundary_id_t boundary_id;
- types::material_id_t material_id;
+ types::boundary_id boundary_id;
+ types::material_id material_id;
};
* consideration.
*/
unsigned int
- n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const;
+ n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const;
/**
* Return the number of
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = numbers::invalid_unsigned_int,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Calls the @p estimate
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Same function as above, but
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Calls the @p estimate
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim>* coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Calls the @p estimate
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Same function as above, but
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Calls the @p estimate
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<spacedim> *coefficients = 0,
const unsigned int n_threads = multithread_info.n_default_threads,
- const types::subdomain_id_t subdomain_id = types::invalid_subdomain_id,
- const types::material_id_t material_id = types::invalid_material_id);
+ const types::subdomain_id subdomain_id = types::invalid_subdomain_id,
+ const types::material_id material_id = types::invalid_material_id);
/**
* Exception
* of boundary nodes and their values. You can get such a list by interpolation
* of a boundary function using the interpolate_boundary_values() function.
* To use it, you have to
- * specify a list of pairs of boundary indicators (of type <tt>types::boundary_id_t</tt>;
+ * specify a list of pairs of boundary indicators (of type <tt>types::boundary_id</tt>;
* see the section in the documentation of the Triangulation class for more
* details) and the according functions denoting the dirichlet boundary values
* of the nodes on boundary faces with this boundary indicator.
void
interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension> &mapping,
const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
std::map<unsigned int,double> &boundary_values,
const std::vector<bool> &component_mask = std::vector<bool>());
template <class DH>
void
interpolate_boundary_values (const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
std::map<unsigned int,double> &boundary_values,
const std::vector<bool> &component_mask = std::vector<bool>());
void
interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension> &mapping,
const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
ConstraintMatrix &constraints,
const std::vector<bool> &component_mask = std::vector<bool>());
template <class DH>
void
interpolate_boundary_values (const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
ConstraintMatrix &constraints,
const std::vector<bool> &component_mask = std::vector<bool>());
void project_boundary_values_curl_conforming (const DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const Mapping<dim>& mapping = StaticMappingQ1<dim>::mapping);
void project_boundary_values_curl_conforming (const hp::DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const hp::MappingCollection<dim, dim>& mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
void project_boundary_values_div_conforming (const DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const Mapping<dim>& mapping = StaticMappingQ1<dim>::mapping);
void project_boundary_values_div_conforming (const hp::DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const hp::MappingCollection<dim, dim>& mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
void
compute_no_normal_flux_constraints (const DH<dim,spacedim> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id_t> &boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
ConstraintMatrix &constraints,
const Mapping<dim, spacedim> &mapping = StaticMappingQ1<dim>::mapping);
const Quadrature<dim-1> &q,
const Function<spacedim> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* Calls the
const Quadrature<dim-1> &q,
const Function<spacedim> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* Same as the set of functions above,
const hp::QCollection<dim-1> &q,
const Function<spacedim> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
/**
* Calls the
const hp::QCollection<dim-1> &q,
const Function<spacedim> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators = std::set<types::boundary_id_t>());
+ const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
//@}
/**
// function to hold on
// all parts of the boundary
typename FunctionMap<spacedim>::type boundary_functions;
- for (types::boundary_id_t c=0; c<types::internal_face_boundary_id; ++c)
+ for (types::boundary_id c=0; c<types::internal_face_boundary_id; ++c)
boundary_functions[c] = &function;
project_boundary_values (dof, boundary_functions, q_boundary,
boundary_values);
const Quadrature<0> &,
const Function<1> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &)
+ const std::set<types::boundary_id> &)
{
Assert (false, ExcImpossibleInDim(1));
}
const Quadrature<0> &,
const Function<2> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &)
+ const std::set<types::boundary_id> &)
{
Assert (false, ExcImpossibleInDim(1));
}
const Quadrature<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
const Quadrature<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
const hp::QCollection<0> &,
const Function<1> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &)
+ const std::set<types::boundary_id> &)
{
Assert (false, ExcImpossibleInDim(1));
}
const hp::QCollection<0> &,
const Function<2> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &)
+ const std::set<types::boundary_id> &)
{
Assert (false, ExcImpossibleInDim(1));
}
const hp::QCollection<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
const hp::FECollection<dim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
const hp::QCollection<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
create_boundary_right_hand_side(hp::StaticMappingQ1<dim>::mapping_collection,
}
const typename DH::face_iterator face = cell->face(face_no);
- const types::boundary_id_t boundary_component = face->boundary_indicator();
+ const types::boundary_id boundary_component = face->boundary_indicator();
// see if this face is
// part of the
void
interpolate_boundary_values (const Mapping<DH::dimension, DH::space_dimension> &mapping,
const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
std::map<unsigned int,double> &boundary_values,
const std::vector<bool> &component_mask)
template <class DH>
void
interpolate_boundary_values (const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
std::map<unsigned int,double> &boundary_values,
const std::vector<bool> &component_mask)
interpolate_boundary_values
(const Mapping<DH::dimension, DH::space_dimension> &mapping,
const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
ConstraintMatrix &constraints,
const std::vector<bool> &component_mask)
void
interpolate_boundary_values
(const DH &dof,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const Function<DH::space_dimension> &boundary_function,
ConstraintMatrix &constraints,
const std::vector<bool> &component_mask)
AssertDimension (dof.get_fe().n_components(), component_mapping.size());
std::vector<unsigned int> dof_to_boundary_mapping;
- std::set<types::boundary_id_t> selected_boundary_components;
+ std::set<types::boundary_id> selected_boundary_components;
for (typename FunctionMap<spacedim>::type::const_iterator i=boundary_functions.begin();
i!=boundary_functions.end(); ++i)
selected_boundary_components.insert (i->first);
project_boundary_values_curl_conforming (const DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const Mapping<dim>& mapping)
{
project_boundary_values_curl_conforming (const hp::DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const hp::MappingCollection<dim>& mapping_collection)
{
project_boundary_values_div_conforming (const DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const Mapping<dim>& mapping)
{
project_boundary_values_div_conforming (const hp::DoFHandler<dim>& dof_handler,
const unsigned int first_vector_component,
const Function<dim>& boundary_function,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
ConstraintMatrix& constraints,
const hp::MappingCollection<dim, dim>& mapping_collection)
{
void
compute_no_normal_flux_constraints (const DH<dim,spacedim> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id_t> &boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
ConstraintMatrix &constraints,
const Mapping<dim, spacedim> &mapping)
{
const typename Triangulation<dim,spacedim>::cell_iterator &dealii_cell,
const typename internal::p4est::types<dim>::quadrant &p4est_cell,
const typename internal::p4est::types<dim>::forest &forest,
- const types::subdomain_id_t my_subdomain)
+ const types::subdomain_id my_subdomain)
{
// check if this cell exists in
// the local p4est cell
public:
RefineAndCoarsenList (const Triangulation<dim,spacedim> &triangulation,
const std::vector<unsigned int> &p4est_tree_to_coarse_cell_permutation,
- const types::subdomain_id_t my_subdomain,
+ const types::subdomain_id my_subdomain,
typename internal::p4est::types<dim>::forest &forest);
/**
RefineAndCoarsenList<dim,spacedim>::
RefineAndCoarsenList (const Triangulation<dim,spacedim> &triangulation,
const std::vector<unsigned int> &p4est_tree_to_coarse_cell_permutation,
- const types::subdomain_id_t my_subdomain,
+ const types::subdomain_id my_subdomain,
typename internal::p4est::types<dim>::forest &forest)
:
forest(forest)
RefineAndCoarsenList<dim,spacedim>::
build_lists (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
const typename internal::p4est::types<dim>::quadrant &p4est_cell,
- const types::subdomain_id_t my_subdomain)
+ const types::subdomain_id my_subdomain)
{
if (!cell->has_children())
{
template <int dim, int spacedim>
- types::subdomain_id_t
+ types::subdomain_id
Triangulation<dim,spacedim>::locally_owned_subdomain () const
{
Assert (dim > 1, ExcNotImplemented());
template <>
- types::subdomain_id_t
+ types::subdomain_id
Triangulation<1,1>::locally_owned_subdomain () const
{
Assert (false, ExcNotImplemented());
template <>
- types::subdomain_id_t
+ types::subdomain_id
Triangulation<1,2>::locally_owned_subdomain () const
{
Assert (false, ExcNotImplemented());
template <>
- types::subdomain_id_t
+ types::subdomain_id
Triangulation<1,3>::locally_owned_subdomain () const
{
Assert (false, ExcNotImplemented());
template <int dim, int spacedim>
- types::subdomain_id_t
+ types::subdomain_id
Triangulation<dim,spacedim>::locally_owned_subdomain () const
{
Assert (false, ExcNotImplemented());
template <>
-unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const
+unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id_t>::const_iterator i=boundary_indicators.begin();
+ for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
i!=boundary_indicators.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
template <>
-unsigned int DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const
+unsigned int DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id_t>::const_iterator i=boundary_indicators.begin();
+ for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
i!=boundary_indicators.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
template<int dim, int spacedim>
unsigned int
-DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const
+DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
{
Assert (boundary_indicators.find (types::internal_face_boundary_id) == boundary_indicators.end(),
ExcInvalidBoundaryIndicator());
static
unsigned int
distribute_dofs (const unsigned int offset,
- const types::subdomain_id_t subdomain_id,
+ const types::subdomain_id subdomain_id,
DoFHandler<dim,spacedim> &dof_handler)
{
const dealii::Triangulation<dim,spacedim> & tria
const unsigned int tree_index,
const typename DoFHandler<dim,spacedim>::cell_iterator &dealii_cell,
const typename dealii::internal::p4est::types<dim>::quadrant &p4est_cell,
- const std::map<unsigned int, std::set<dealii::types::subdomain_id_t> > &vertices_with_ghost_neighbors,
- std::map<dealii::types::subdomain_id_t, typename types<dim>::cellinfo> &needs_to_get_cell)
+ const std::map<unsigned int, std::set<dealii::types::subdomain_id> > &vertices_with_ghost_neighbors,
+ std::map<dealii::types::subdomain_id, typename types<dim>::cellinfo> &needs_to_get_cell)
{
// see if we have to
// recurse...
// check each vertex if
// it is interesting and
// push dofindices if yes
- std::set<dealii::types::subdomain_id_t> send_to;
+ std::set<dealii::types::subdomain_id> send_to;
for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
{
- const std::map<unsigned int, std::set<dealii::types::subdomain_id_t> >::const_iterator
+ const std::map<unsigned int, std::set<dealii::types::subdomain_id> >::const_iterator
neighbor_subdomains_of_vertex
= vertices_with_ghost_neighbors.find (dealii_cell->vertex_index(v));
local_dof_indices (dealii_cell->get_fe().dofs_per_cell);
dealii_cell->get_dof_indices (local_dof_indices);
- for (std::set<dealii::types::subdomain_id_t>::iterator it=send_to.begin();
+ for (std::set<dealii::types::subdomain_id>::iterator it=send_to.begin();
it!=send_to.end();++it)
{
- const dealii::types::subdomain_id_t subdomain = *it;
+ const dealii::types::subdomain_id subdomain = *it;
// get an iterator
// to what needs to
// already exists),
// or create such
// an object
- typename std::map<dealii::types::subdomain_id_t, typename types<dim>::cellinfo>::iterator
+ typename std::map<dealii::types::subdomain_id, typename types<dim>::cellinfo>::iterator
p
= needs_to_get_cell.insert (std::make_pair(subdomain,
typename types<dim>::cellinfo()))
void
communicate_dof_indices_on_marked_cells
(const DoFHandler<1,spacedim> &,
- const std::map<unsigned int, std::set<dealii::types::subdomain_id_t> > &,
+ const std::map<unsigned int, std::set<dealii::types::subdomain_id> > &,
const std::vector<unsigned int> &,
const std::vector<unsigned int> &)
{
void
communicate_dof_indices_on_marked_cells
(const DoFHandler<dim,spacedim> &dof_handler,
- const std::map<unsigned int, std::set<dealii::types::subdomain_id_t> > &vertices_with_ghost_neighbors,
+ const std::map<unsigned int, std::set<dealii::types::subdomain_id> > &vertices_with_ghost_neighbors,
const std::vector<unsigned int> &coarse_cell_to_p4est_tree_permutation,
const std::vector<unsigned int> &p4est_tree_to_coarse_cell_permutation)
{
// dof_indices for the
// interested neighbors
typedef
- std::map<dealii::types::subdomain_id_t, typename types<dim>::cellinfo>
+ std::map<dealii::types::subdomain_id, typename types<dim>::cellinfo>
cellmap_t;
cellmap_t needs_to_get_cells;
// mark all own cells, that miss some
// dof_data and collect the neighbors
// that are going to send stuff to us
- std::set<dealii::types::subdomain_id_t> senders;
+ std::set<dealii::types::subdomain_id> senders;
{
std::vector<unsigned int> local_dof_indices;
typename DoFHandler<dim,spacedim>::active_cell_iterator
// subdomain to the vertex and
// keep track of interesting
// neighbors
- std::map<unsigned int, std::set<dealii::types::subdomain_id_t> >
+ std::map<unsigned int, std::set<dealii::types::subdomain_id> >
vertices_with_ghost_neighbors;
for (typename DoFHandler<dim,spacedim>::active_cell_iterator
cell = dof_handler.begin_active();
// subdomain to the vertex and
// keep track of interesting
// neighbors
- std::map<unsigned int, std::set<dealii::types::subdomain_id_t> >
+ std::map<unsigned int, std::set<dealii::types::subdomain_id> >
vertices_with_ghost_neighbors;
for (typename DoFHandler<dim,spacedim>::active_cell_iterator
cell = dof_handler.begin_active();
for (unsigned int c=0; c<n_buckets; ++c)
{
shifts[c]=cumulated;
- for (types::subdomain_id_t i=0; i<tria->locally_owned_subdomain(); ++i)
+ for (types::subdomain_id i=0; i<tria->locally_owned_subdomain(); ++i)
shifts[c] += all_dof_counts[c+n_buckets*i];
for (unsigned int i=0; i<Utilities::MPI::n_mpi_processes (tria->get_communicator()); ++i)
cumulated += all_dof_counts[c+n_buckets*i];
// first get the association of each dof
// with a subdomain and determine the total
// number of subdomain ids used
- std::vector<types::subdomain_id_t> subdomain_association (n_dofs);
+ std::vector<types::subdomain_id> subdomain_association (n_dofs);
DoFTools::get_subdomain_association (dof_handler,
subdomain_association);
const unsigned int n_subdomains
SparsityPattern &sparsity,
const ConstraintMatrix &constraints,
const bool keep_constrained_dofs,
- const types::subdomain_id_t subdomain_id)
+ const types::subdomain_id subdomain_id)
{
const unsigned int n_dofs = dof.n_dofs();
SparsityPattern &sparsity,
const ConstraintMatrix &constraints,
const bool keep_constrained_dofs,
- const types::subdomain_id_t subdomain_id)
+ const types::subdomain_id subdomain_id)
{
const unsigned int n_dofs = dof.n_dofs();
SparsityPattern &sparsity,
const ConstraintMatrix &constraints,
const bool keep_constrained_dofs,
- const types::subdomain_id_t subdomain_id)
+ const types::subdomain_id subdomain_id)
{
const unsigned int n_dofs = dof.n_dofs();
template<typename DH>
void
make_periodicity_constraints (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const int direction,
dealii::ConstraintMatrix &constraint_matrix,
const std::vector<bool> &component_mask)
template<typename DH>
void
make_periodicity_constraints (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
const int direction,
dealii::Tensor<1,DH::space_dimension>
&offset,
extract_boundary_dofs (const DH &dof_handler,
const std::vector<bool> &component_select,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
Assert ((dynamic_cast<const parallel::distributed::Triangulation<DH::dimension,DH::space_dimension>*>
(&dof_handler.get_tria())
extract_boundary_dofs (const DH &dof_handler,
const std::vector<bool> &component_select,
IndexSet &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
AssertDimension (component_select.size(), n_components(dof_handler));
Assert (boundary_indicators.find (types::internal_face_boundary_id) == boundary_indicators.end(),
extract_dofs_with_support_on_boundary (const DH &dof_handler,
const std::vector<bool> &component_select,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id_t> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_indicators)
{
AssertDimension (component_select.size(), n_components(dof_handler));
Assert (boundary_indicators.find (types::internal_face_boundary_id) == boundary_indicators.end(),
template <class DH>
void
extract_subdomain_dofs (const DH &dof_handler,
- const types::subdomain_id_t subdomain_id,
+ const types::subdomain_id subdomain_id,
std::vector<bool> &selected_dofs)
{
Assert(selected_dofs.size() == dof_handler.n_dofs(),
template <class DH>
void
get_subdomain_association (const DH &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association)
+ std::vector<types::subdomain_id> &subdomain_association)
{
// if the Triangulation is distributed, the
// only thing we can usefully ask is for
ExcMessage ("You can't call this function for meshes that "
"have artificial cells."));
- const types::subdomain_id_t subdomain_id = cell->subdomain_id();
+ const types::subdomain_id subdomain_id = cell->subdomain_id();
const unsigned int dofs_per_cell = cell->get_fe().dofs_per_cell;
local_dof_indices.resize (dofs_per_cell);
cell->get_dof_indices (local_dof_indices);
template <class DH>
unsigned int
count_dofs_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain)
+ const types::subdomain_id subdomain)
{
- std::vector<types::subdomain_id_t> subdomain_association (dof_handler.n_dofs());
+ std::vector<types::subdomain_id> subdomain_association (dof_handler.n_dofs());
get_subdomain_association (dof_handler, subdomain_association);
return std::count (subdomain_association.begin(),
template <class DH>
IndexSet
dof_indices_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain)
+ const types::subdomain_id subdomain)
{
// If we have a distributed::Triangulation only
template <class DH>
void
count_dofs_with_subdomain_association (const DH &dof_handler,
- const types::subdomain_id_t subdomain,
+ const types::subdomain_id subdomain,
std::vector<unsigned int> &n_dofs_on_subdomain)
{
Assert (n_dofs_on_subdomain.size() == dof_handler.get_fe().n_components(),
}
#endif
- std::vector<types::subdomain_id_t> subdomain_association (dof_handler.n_dofs());
+ std::vector<types::subdomain_id> subdomain_association (dof_handler.n_dofs());
get_subdomain_association (dof_handler, subdomain_association);
std::vector<unsigned char> component_association (dof_handler.n_dofs());
template <class DH>
void map_dof_to_boundary_indices (
const DH &dof_handler,
- const std::set<types::boundary_id_t> &boundary_indicators,
+ const std::set<types::boundary_id> &boundary_indicators,
std::vector<unsigned int> &mapping)
{
Assert (&dof_handler.get_fe() != 0, ExcNoFESelected());
template
void
DoFTools::make_periodicity_constraints(const DH &,
- const types::boundary_id_t,
+ const types::boundary_id,
const int,
dealii::ConstraintMatrix &,
const std::vector<bool> &);
template
void
DoFTools::make_periodicity_constraints(const DH &,
- const types::boundary_id_t,
+ const types::boundary_id,
const int,
dealii::Tensor<1,DH::space_dimension> &,
dealii::ConstraintMatrix &,
(const DoFHandler<deal_II_dimension> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
void
DoFTools::extract_boundary_dofs<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
void
(const DoFHandler<deal_II_dimension> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
void
DoFTools::extract_dofs_with_support_on_boundary<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
void
void
DoFTools::extract_subdomain_dofs<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &dof_handler,
- const types::subdomain_id_t subdomain_id,
+ const types::subdomain_id subdomain_id,
std::vector<bool> &selected_dofs);
template
void
DoFTools::extract_subdomain_dofs<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &dof_handler,
- const types::subdomain_id_t subdomain_id,
+ const types::subdomain_id subdomain_id,
std::vector<bool> &selected_dofs);
template
void
DoFTools::get_subdomain_association<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
void
DoFTools::get_subdomain_association<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
#if deal_II_dimension < 3
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::get_subdomain_association<DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
void
DoFTools::get_subdomain_association<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
void
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
#endif
(const DoFHandler<1,3> &,
const std::vector<bool> &,
std::vector<bool> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
template
void
DoFTools::get_subdomain_association<DoFHandler<1,3> >
(const DoFHandler<1,3> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
void
DoFTools::get_subdomain_association<hp::DoFHandler<1,3> >
(const hp::DoFHandler<1,3> &dof_handler,
- std::vector<types::subdomain_id_t> &subdomain_association);
+ std::vector<types::subdomain_id> &subdomain_association);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<DoFHandler<1,3> >
(const DoFHandler<1,3> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<DoFHandler<1,3> >
(const DoFHandler<1,3> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<DoFHandler<1,3> >
(const DoFHandler<1,3> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
template
unsigned int
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<1,3> >
(const hp::DoFHandler<1,3> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<hp::DoFHandler<1,3> >
(const hp::DoFHandler<1,3> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<hp::DoFHandler<1,3> >
(const hp::DoFHandler<1,3> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
#endif
unsigned int
DoFTools::count_dofs_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
IndexSet
DoFTools::dof_indices_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
void
DoFTools::count_dofs_with_subdomain_association<MGDoFHandler<deal_II_dimension> >
(const MGDoFHandler<deal_II_dimension> &,
- const types::subdomain_id_t,
+ const types::subdomain_id,
std::vector<unsigned int> &);
void
DoFTools::map_dof_to_boundary_indices<DoFHandler<deal_II_dimension> >
(const DoFHandler<deal_II_dimension> &,
- const std::set<types::boundary_id_t> &,
+ const std::set<types::boundary_id> &,
std::vector<unsigned int> &);
template
void
DoFTools::map_dof_to_boundary_indices<hp::DoFHandler<deal_II_dimension> >
(const hp::DoFHandler<deal_II_dimension> &,
- const std::set<types::boundary_id_t> &,
+ const std::set<types::boundary_id> &,
std::vector<unsigned int> &);
template
void
DoFTools::map_dof_to_boundary_indices<DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const std::set<types::boundary_id_t> &,
+ const std::set<types::boundary_id> &,
std::vector<unsigned int> &);
template
void
DoFTools::map_dof_to_boundary_indices<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> >
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1> &,
- const std::set<types::boundary_id_t> &,
+ const std::set<types::boundary_id> &,
std::vector<unsigned int> &);
template
void
DoFTools::map_dof_to_boundary_indices<DoFHandler<1,3> >
(const DoFHandler<1,3> &,
- const std::set<types::boundary_id_t> &,
+ const std::set<types::boundary_id> &,
std::vector<unsigned int> &);
template
// we can only interpolate u1 on
// a cell, which this processor owns,
// so we have to know the subdomain_id
- const types::subdomain_id_t subdomain_id =
+ const types::subdomain_id subdomain_id =
dof1.get_tria().locally_owned_subdomain();
for (; cell1!=endc1; ++cell1, ++cell2)
Vector<typename OutVector::value_type> u1_local(dofs_per_cell1);
Vector<typename OutVector::value_type> u1_int_local(dofs_per_cell1);
- const types::subdomain_id_t subdomain_id =
+ const types::subdomain_id subdomain_id =
dof1.get_tria().locally_owned_subdomain();
typename DoFHandler<dim,spacedim>::active_cell_iterator cell = dof1.begin_active(),
Vector<typename OutVector::value_type> u1_local(DoFTools::max_dofs_per_cell(dof1));
Vector<typename OutVector::value_type> u1_int_local(DoFTools::max_dofs_per_cell(dof1));
- const types::subdomain_id_t subdomain_id =
+ const types::subdomain_id subdomain_id =
dof1.get_tria().locally_owned_subdomain();
typename DH<dim>::active_cell_iterator cell = dof1.begin_active(),
Vector<typename OutVector::value_type> u1_local(dofs_per_cell);
Vector<typename OutVector::value_type> u1_diff_local(dofs_per_cell);
- const types::subdomain_id_t subdomain_id =
+ const types::subdomain_id subdomain_id =
dof1.get_tria().locally_owned_subdomain();
FullMatrix<double> difference_matrix(dofs_per_cell, dofs_per_cell);
Triangulation<1>& tria,
const std::vector< std::vector<double> >& spacing,
const Point<1>& p,
- const Table<1,types::material_id_t>& material_id,
+ const Table<1,types::material_id>& material_id,
const bool colorize)
{
// contributed by Yaqi Wang 2006
Triangulation<2>& tria,
const std::vector< std::vector<double> >& spacing,
const Point<2>& p,
- const Table<2,types::material_id_t>& material_id,
+ const Table<2,types::material_id>& material_id,
const bool colorize)
{
// contributed by Yaqi Wang 2006
Triangulation<3>& tria,
const std::vector< std::vector<double> >& spacing,
const Point<3>& p,
- const Table<3,types::material_id_t>& material_id,
+ const Table<3,types::material_id>& material_id,
const bool colorize)
{
// contributed by Yaqi Wang 2006
for (unsigned int i1=0;i1<4;++i1)
vertices[k++] = Point<2>(coords[i1], coords[i0]);
- const types::material_id_t materials[9] = { 5, 4, 6,
+ const types::material_id materials[9] = { 5, 4, 6,
1, 0, 2,
9, 8,10
};
for (unsigned int x=0;x<4;++x)
vertices[k++] = Point<3>(coords[x], coords[y], coords[z]);
- const types::material_id_t materials[27] = {
+ const types::material_id materials[27] = {
21,20,22,
17,16,18,
25,24,26,
in >> cells.back().vertices[i];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::material_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::material_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::material_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::material_id>::max()));
// we use only material_ids in the range from 0 to types::invalid_material_id-1
Assert(material_id < types::invalid_material_id,
ExcIndexRange(material_id,0,types::invalid_material_id));
- cells.back().material_id = static_cast<types::material_id_t>(material_id);
+ cells.back().material_id = static_cast<types::material_id>(material_id);
// transform from ucd to
// consecutive numbering
>> subcelldata.boundary_lines.back().vertices[1];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::boundary_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::boundary_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id>::max()));
// we use only boundary_ids in the range from 0 to types::internal_face_boundary_id-1
Assert(material_id < types::internal_face_boundary_id,
ExcIndexRange(material_id,0,types::internal_face_boundary_id));
subcelldata.boundary_lines.back().boundary_id
- = static_cast<types::boundary_id_t>(material_id);
+ = static_cast<types::boundary_id>(material_id);
// transform from ucd to
// consecutive numbering
>> subcelldata.boundary_quads.back().vertices[3];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::boundary_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::boundary_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id>::max()));
// we use only boundary_ids in the range from 0 to types::internal_face_boundary_id-1
Assert(material_id < types::internal_face_boundary_id,
ExcIndexRange(material_id,0,types::internal_face_boundary_id));
subcelldata.boundary_quads.back().boundary_id
- = static_cast<types::boundary_id_t>(material_id);
+ = static_cast<types::boundary_id>(material_id);
// transform from ucd to
// consecutive numbering
in >> cells.back().vertices[i];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::material_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::material_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::material_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::material_id>::max()));
// we use only material_ids in the range from 0 to types::invalid_material_id-1
Assert(material_id < types::invalid_material_id,
ExcIndexRange(material_id,0,types::invalid_material_id));
- cells.back().material_id = static_cast<types::material_id_t>(material_id);
+ cells.back().material_id = static_cast<types::material_id>(material_id);
// transform from ucd to
// consecutive numbering
>> subcelldata.boundary_lines.back().vertices[1];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::boundary_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::boundary_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id>::max()));
// we use only boundary_ids in the range from 0 to types::internal_face_boundary_id-1
Assert(material_id < types::internal_face_boundary_id,
ExcIndexRange(material_id,0,types::internal_face_boundary_id));
subcelldata.boundary_lines.back().boundary_id
- = static_cast<types::boundary_id_t>(material_id);
+ = static_cast<types::boundary_id>(material_id);
// transform from ucd to
// consecutive numbering
>> subcelldata.boundary_quads.back().vertices[3];
// to make sure that the cast wont fail
- Assert(material_id<= std::numeric_limits<types::boundary_id_t>::max(),
- ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id_t>::max()));
+ Assert(material_id<= std::numeric_limits<types::boundary_id>::max(),
+ ExcIndexRange(material_id,0,std::numeric_limits<types::boundary_id>::max()));
// we use only boundary_ids in the range from 0 to types::internal_face_boundary_id-1
Assert(material_id < types::internal_face_boundary_id,
ExcIndexRange(material_id,0,types::internal_face_boundary_id));
subcelldata.boundary_quads.back().boundary_id
- = static_cast<types::boundary_id_t>(material_id);
+ = static_cast<types::boundary_id>(material_id);
// transform from gmsh to
// consecutive numbering
bmarker_var->get(&*bmarker.begin(), n_bquads);
// we only handle boundary
// indicators that fit into an
- // types::boundary_id_t. Also, we don't
+ // types::boundary_id. Also, we don't
// take types::internal_face_boundary_id
// as it denotes an internal face
for (unsigned int i=0; i<bmarker.size(); ++i)
subcelldata.boundary_quads[i].vertices[v]=bvertex_indices[
i*GeometryInfo<dim>::vertices_per_face+v];
subcelldata.boundary_quads[i].boundary_id
- = static_cast<types::boundary_id_t>(bmarker[i]);
+ = static_cast<types::boundary_id>(bmarker[i]);
}
GridTools::delete_unused_vertices(vertices, cells, subcelldata);
{
Triangulation<dim>::face_iterator
face = cell->face(face_reorder[f]);
- const types::boundary_id_t bi = face->boundary_indicator();
+ const types::boundary_id bi = face->boundary_indicator();
if (bi != types::internal_face_boundary_id)
{
// Code for polyline
template <int dim, int spacedim>
void
get_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
- std::vector<types::subdomain_id_t> &subdomain)
+ std::vector<types::subdomain_id> &subdomain)
{
Assert (subdomain.size() == triangulation.n_active_cells(),
ExcDimensionMismatch (subdomain.size(),
unsigned int
count_cells_with_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
- const types::subdomain_id_t subdomain)
+ const types::subdomain_id subdomain)
{
unsigned int count = 0;
for (typename Triangulation<dim, spacedim>::active_cell_iterator
typename Container<dim,spacedim>::face_iterator>
extract_boundary_mesh (const Container<dim,spacedim> &volume_mesh,
Container<dim-1,spacedim> &surface_mesh,
- const std::set<types::boundary_id_t> &boundary_ids)
+ const std::set<types::boundary_id> &boundary_ids)
{
// Assumption:
// We are relying below on the fact that Triangulation::create_triangulation(...) will keep the order
}
c_data.vertices[j] = map_vert_index[v_index];
- c_data.material_id = static_cast<types::material_id_t>(face->boundary_indicator());
+ c_data.material_id = static_cast<types::material_id>(face->boundary_indicator());
}
cells.push_back(c_data);
std::map<CellIterator, CellIterator>
collect_periodic_cell_pairs (const CellIterator &begin,
const typename identity<CellIterator>::type &end,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
int direction,
const dealii::Tensor<1,CellIterator::AccessorType::space_dimension>
&offset)
template<typename DH>
std::map<typename DH::cell_iterator, typename DH::cell_iterator>
collect_periodic_cell_pairs (const DH &dof_handler,
- const types::boundary_id_t boundary_component,
+ const types::boundary_id boundary_component,
int direction,
const dealii::Tensor<1,DH::space_dimension>
&offset)
template
void get_subdomain_association (const Triangulation<deal_II_dimension, deal_II_space_dimension> &,
- std::vector<types::subdomain_id_t> &);
+ std::vector<types::subdomain_id> &);
template
unsigned int count_cells_with_subdomain_association(
const Triangulation<deal_II_dimension, deal_II_space_dimension> &,
- const types::subdomain_id_t);
+ const types::subdomain_id);
template
double
Container<deal_II_dimension,deal_II_space_dimension>::face_iterator>
extract_boundary_mesh (const Container<deal_II_dimension, deal_II_space_dimension> &mesh,
Container<deal_II_dimension-1,deal_II_space_dimension> &boundary_mesh,
- const std::set<types::boundary_id_t> &boundary_ids);
+ const std::set<types::boundary_id> &boundary_ids);
\}
#endif
#endif
std::map<X::cell_iterator, X::cell_iterator>
collect_periodic_cell_pairs(const X::cell_iterator &,
const X::cell_iterator &,
- const types::boundary_id_t,
+ const types::boundary_id,
int,
const Tensor<1,deal_II_space_dimension> &);
template
std::map<X::cell_iterator, X::cell_iterator>
collect_periodic_cell_pairs (const X&,
- const types::boundary_id_t,
+ const types::boundary_id,
int,
const Tensor<1,deal_II_space_dimension> &);
switch_1->line_orientation(1),
switch_1->line_orientation(2),
switch_1->line_orientation(3) };
- const types::boundary_id_t switch_1_boundary_indicator=switch_1->boundary_indicator();
+ const types::boundary_id switch_1_boundary_indicator=switch_1->boundary_indicator();
const unsigned int switch_1_user_index=switch_1->user_index();
const bool switch_1_user_flag=switch_1->user_flag_set();
// An assert to make sure that the
// static_cast in the next line has
// the chance to give reasonable results.
- Assert(cell->material_id()<= std::numeric_limits<types::material_id_t>::max(),
- ExcIndexRange(cell->material_id(),0,std::numeric_limits<types::material_id_t>::max()));
+ Assert(cell->material_id()<= std::numeric_limits<types::material_id>::max(),
+ ExcIndexRange(cell->material_id(),0,std::numeric_limits<types::material_id>::max()));
// new vertex is
// placed on the
// stored in the
// boundary class
triangulation.vertices[next_unused_vertex] =
- triangulation.get_boundary(static_cast<types::boundary_id_t>(cell->material_id()))
+ triangulation.get_boundary(static_cast<types::boundary_id>(cell->material_id()))
.get_new_point_on_quad (cell);
}
}
(cell->vertex(0) + cell->vertex(1)) / 2;
else
triangulation.vertices[next_unused_vertex] =
- triangulation.get_boundary(static_cast<types::boundary_id_t>(cell->material_id()))
+ triangulation.get_boundary(static_cast<types::boundary_id>(cell->material_id()))
.get_new_point_on_line(cell);
triangulation.vertices_used[next_unused_vertex] = true;
switch_1->line_orientation(1),
switch_1->line_orientation(2),
switch_1->line_orientation(3)};
- const types::boundary_id_t switch_1_boundary_indicator=switch_1->boundary_indicator();
+ const types::boundary_id switch_1_boundary_indicator=switch_1->boundary_indicator();
const unsigned int switch_1_user_index=switch_1->user_index();
const bool switch_1_user_flag=switch_1->user_flag_set();
const RefinementCase<dim-1> switch_1_refinement_case=switch_1->refinement_case();
{
if (dim == 1)
vertex_to_boundary_id_map_1d
- = new std::map<unsigned int, types::boundary_id_t>();
+ = new std::map<unsigned int, types::boundary_id>();
// connect the any_change signal to the other signals
signals.create.connect (signals.any_change);
template <int dim, int spacedim>
void
-Triangulation<dim, spacedim>::set_boundary (const types::boundary_id_t number,
+Triangulation<dim, spacedim>::set_boundary (const types::boundary_id number,
const Boundary<dim, spacedim>& boundary_object)
{
Assert(number < types::internal_face_boundary_id, ExcIndexRange(number,0,types::internal_face_boundary_id));
template <int dim, int spacedim>
void
-Triangulation<dim, spacedim>::set_boundary (const types::boundary_id_t number)
+Triangulation<dim, spacedim>::set_boundary (const types::boundary_id number)
{
Assert(number < types::internal_face_boundary_id, ExcIndexRange(number,0,types::internal_face_boundary_id));
template <int dim, int spacedim>
const Boundary<dim, spacedim> &
-Triangulation<dim, spacedim>::get_boundary (const types::boundary_id_t number) const
+Triangulation<dim, spacedim>::get_boundary (const types::boundary_id number) const
{
Assert(number<types::internal_face_boundary_id, ExcIndexRange(number,0,types::internal_face_boundary_id));
//look, if there is a boundary stored at
//boundary_id number.
- typename std::map<types::boundary_id_t, SmartPointer<const Boundary<dim, spacedim>, Triangulation<dim, spacedim> > >::const_iterator it
+ typename std::map<types::boundary_id, SmartPointer<const Boundary<dim, spacedim>, Triangulation<dim, spacedim> > >::const_iterator it
= boundary.find(number);
if(it != boundary.end())
template <int dim, int spacedim>
-std::vector<types::boundary_id_t>
+std::vector<types::boundary_id>
Triangulation<dim, spacedim>::get_boundary_indicators () const
{
// in 1d, we store a map of all used
// purposes
if (dim == 1)
{
- std::vector<types::boundary_id_t> boundary_indicators;
- for (std::map<unsigned int, types::boundary_id_t>::const_iterator
+ std::vector<types::boundary_id> boundary_indicators;
+ for (std::map<unsigned int, types::boundary_id>::const_iterator
p = vertex_to_boundary_id_map_1d->begin();
p != vertex_to_boundary_id_map_1d->end();
++p)
const unsigned int n_bi=
std::count(bi_exists.begin(), bi_exists.end(), true);
- std::vector<types::boundary_id_t> boundary_indicators(n_bi);
+ std::vector<types::boundary_id> boundary_indicators(n_bi);
unsigned int bi_counter=0;
for (unsigned int i=0; i<bi_exists.size(); ++i)
if (bi_exists[i]==true)
faces = new internal::Triangulation::TriaFaces<dim>(*old_tria.faces);
- typename std::map<types::boundary_id_t, SmartPointer<const Boundary<dim, spacedim> , Triangulation<dim, spacedim> > >::const_iterator
+ typename std::map<types::boundary_id, SmartPointer<const Boundary<dim, spacedim> , Triangulation<dim, spacedim> > >::const_iterator
bdry_iterator = old_tria.boundary.begin();
for (; bdry_iterator != old_tria.boundary.end() ; bdry_iterator++)
boundary[bdry_iterator->first] = bdry_iterator->second;
{
delete vertex_to_boundary_id_map_1d;
vertex_to_boundary_id_map_1d
- = (new std::map<unsigned int, types::boundary_id_t>
+ = (new std::map<unsigned int, types::boundary_id>
(*old_tria.vertex_to_boundary_id_map_1d));
}
template <int dim, int spacedim>
-types::subdomain_id_t
+types::subdomain_id
Triangulation<dim,spacedim>::locally_owned_subdomain () const
{
return types::invalid_subdomain_id;
// functions that currently only exist for <1,1> and <1,2>
// template
// const Boundary<1,3> &
-// Triangulation<1,3>::get_boundary (const types::boundary_id_t number) const;
+// Triangulation<1,3>::get_boundary (const types::boundary_id number) const;
DEAL_II_NAMESPACE_CLOSE
template <int dim, int spacedim>
-types::material_id_t CellAccessor<dim, spacedim>::material_id () const
+types::material_id CellAccessor<dim, spacedim>::material_id () const
{
Assert (this->used(), TriaAccessorExceptions::ExcCellNotUsed());
return this->tria->levels[this->present_level]->cells.boundary_or_material_id[this->present_index].material_id;
template <int dim, int spacedim>
-void CellAccessor<dim, spacedim>::set_material_id (const types::material_id_t mat_id) const
+void CellAccessor<dim, spacedim>::set_material_id (const types::material_id mat_id) const
{
Assert (this->used(), TriaAccessorExceptions::ExcCellNotUsed());
Assert ( mat_id < types::invalid_material_id, ExcIndexRange(mat_id,0,types::invalid_material_id));
template <int dim, int spacedim>
-void CellAccessor<dim, spacedim>::recursively_set_material_id (const types::material_id_t mat_id) const
+void CellAccessor<dim, spacedim>::recursively_set_material_id (const types::material_id mat_id) const
{
set_material_id (mat_id);
template <int dim, int spacedim>
-types::subdomain_id_t CellAccessor<dim, spacedim>::subdomain_id () const
+types::subdomain_id CellAccessor<dim, spacedim>::subdomain_id () const
{
Assert (this->used(), TriaAccessorExceptions::ExcCellNotUsed());
return this->tria->levels[this->present_level]->subdomain_ids[this->present_index];
template <int dim, int spacedim>
void
-CellAccessor<dim, spacedim>::set_subdomain_id (const types::subdomain_id_t new_subdomain_id) const
+CellAccessor<dim, spacedim>::set_subdomain_id (const types::subdomain_id new_subdomain_id) const
{
Assert (this->used(), TriaAccessorExceptions::ExcCellNotUsed());
this->tria->levels[this->present_level]->subdomain_ids[this->present_index]
template <int dim, int spacedim>
void
CellAccessor<dim, spacedim>::
-recursively_set_subdomain_id (const types::subdomain_id_t new_subdomain_id) const
+recursively_set_subdomain_id (const types::subdomain_id new_subdomain_id) const
{
set_subdomain_id (new_subdomain_id);
template <>
- unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const
+ unsigned int DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
{
Assert (finite_elements != 0, ExcNoFESelected());
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id_t>::const_iterator i=boundary_indicators.begin();
+ for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
i!=boundary_indicators.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
}
template <>
- unsigned int DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id_t> &) const
+ unsigned int DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id> &) const
{
Assert(false,ExcNotImplemented());
return 0;
}
template <>
- unsigned int DoFHandler<1,3>::n_boundary_dofs (const std::set<types::boundary_id_t> &) const
+ unsigned int DoFHandler<1,3>::n_boundary_dofs (const std::set<types::boundary_id> &) const
{
Assert(false,ExcNotImplemented());
return 0;
template<int dim, int spacedim>
unsigned int
- DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id_t> &boundary_indicators) const
+ DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
{
Assert (finite_elements != 0, ExcNoFESelected());
Assert (boundary_indicators.find (types::internal_face_boundary_id) == boundary_indicators.end(),
template <>
- unsigned int DoFHandler<2,3>::n_boundary_dofs (const std::set<types::boundary_id_t> &) const
+ unsigned int DoFHandler<2,3>::n_boundary_dofs (const std::set<types::boundary_id> &) const
{
Assert(false,ExcNotImplemented());
return 0;
{
const typename MGDoFHandler<dim,spacedim>::face_iterator
face = cell->face(face_no);
- const types::boundary_id_t bi = face->boundary_indicator();
+ const types::boundary_id bi = face->boundary_indicator();
// Face is listed in
// boundary map
if (function_map.find(bi) != function_map.end())
}
typename MGDoFHandler<dim,spacedim>::face_iterator face = cell->face(face_no);
- const types::boundary_id_t boundary_component = face->boundary_indicator();
+ const types::boundary_id boundary_component = face->boundary_indicator();
if (function_map.find(boundary_component) != function_map.end())
// face is of the right component
{
* The subdomain id we are to care
* for.
*/
- const types::subdomain_id_t subdomain_id;
+ const types::subdomain_id subdomain_id;
/**
* The material id we are to care
* for.
*/
- const types::material_id_t material_id;
+ const types::material_id material_id;
/**
* Some more references to input data to
const dealii::hp::MappingCollection<DH::dimension, DH::space_dimension> &mapping,
const bool need_quadrature_points,
const unsigned int n_solution_vectors,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
const typename FunctionMap<spacedim>::type *neumann_bc,
const std::vector<bool> component_mask,
const Function<spacedim> *coefficients);
const dealii::hp::MappingCollection<DH::dimension, DH::space_dimension> &mapping,
const bool need_quadrature_points,
const unsigned int n_solution_vectors,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id,
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id,
const typename FunctionMap<spacedim>::type *neumann_bc,
const std::vector<bool> component_mask,
const Function<spacedim> *coefficients)
// difference between normal
// derivative and boundary function
{
- const types::boundary_id_t boundary_indicator = face->boundary_indicator();
+ const types::boundary_id boundary_indicator = face->boundary_indicator();
Assert (parallel_data.neumann_bc->find(boundary_indicator) !=
parallel_data.neumann_bc->end(),
{
const unsigned int n_solution_vectors = solutions.size();
- const types::subdomain_id_t subdomain_id = parallel_data.subdomain_id;
+ const types::subdomain_id subdomain_id = parallel_data.subdomain_id;
const unsigned int material_id = parallel_data.material_id;
// empty our own copy of the local face
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
// just pass on to the other function
const std::vector<const InputVector *> solutions (1, &solution);
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
// just pass on to the other function
const std::vector<const InputVector *> solutions (1, &solution);
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
const std::vector<bool> &/*component_mask_*/,
const Function<spacedim> */*coefficient*/,
const unsigned int,
- const types::subdomain_id_t /*subdomain_id*/,
- const types::material_id_t /*material_id*/)
+ const types::subdomain_id /*subdomain_id*/,
+ const types::material_id /*material_id*/)
{
Assert (false, ExcInternalError());
}
const std::vector<bool> &component_mask_,
const Function<spacedim> *coefficient,
const unsigned int,
- const types::subdomain_id_t subdomain_id_,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id_,
+ const types::material_id material_id)
{
#ifdef DEAL_II_USE_P4EST
if (dynamic_cast<const parallel::distributed::Triangulation<1,spacedim>*>
"valid subdomain_id that can be passed here is the "
"one that corresponds to the locally owned subdomain id."));
- const types::subdomain_id_t subdomain_id
+ const types::subdomain_id subdomain_id
= ((dynamic_cast<const parallel::distributed::Triangulation<1,spacedim>*>
(&dof_handler.get_tria())
!= 0)
:
subdomain_id_);
#else
- const types::subdomain_id_t subdomain_id
+ const types::subdomain_id subdomain_id
= subdomain_id_;
#endif
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
// just pass on to the other function
const std::vector<const InputVector *> solutions (1, &solution);
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<dim,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
// just pass on to the other function
const std::vector<const InputVector *> solutions (1, &solution);
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
const std::vector<bool> &component_mask_,
const Function<spacedim> *coefficients,
const unsigned int ,
- const types::subdomain_id_t subdomain_id_,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id_,
+ const types::material_id material_id)
{
#ifdef DEAL_II_USE_P4EST
if (dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
"valid subdomain_id that can be passed here is the "
"one that corresponds to the locally owned subdomain id."));
- const types::subdomain_id_t subdomain_id
+ const types::subdomain_id subdomain_id
= ((dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
(&dof_handler.get_tria())
!= 0)
:
subdomain_id_);
#else
- const types::subdomain_id_t subdomain_id
+ const types::subdomain_id subdomain_id
= subdomain_id_;
#endif
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
// forward to the function with the QCollection
estimate (mapping, dof_handler,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
const std::vector<bool> &component_mask,
const Function<spacedim> *coefficients,
const unsigned int n_threads,
- const types::subdomain_id_t subdomain_id,
- const types::material_id_t material_id)
+ const types::subdomain_id subdomain_id,
+ const types::material_id material_id)
{
Assert (DEAL_II_COMPAT_MAPPING, ExcCompatibility("mapping"));
estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
const Function<deal_II_dimension> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t);\
+ const types::material_id);\
#if deal_II_dimension == 2 || deal_II_dimension == 1
const Function<deal_II_dimension+1> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension+1> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension+1> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t); \
+ const types::material_id); \
\
template \
void \
const Function<deal_II_dimension+1> *, \
const unsigned int , \
const unsigned int , \
- const types::material_id_t);\
+ const types::material_id);\
#else
#define INSTANTIATE_CODIM(InputVector,DH,Q)
void interpolate_boundary_values
(const Mapping<deal_II_dimension,deal_II_space_dimension> &,
const DH<deal_II_dimension,deal_II_space_dimension> &,
- const types::boundary_id_t,
+ const types::boundary_id,
const Function<deal_II_space_dimension> &,
std::map<unsigned int,double> &,
const std::vector<bool> &);
template
void interpolate_boundary_values (
const DH<deal_II_dimension,deal_II_space_dimension> &,
- const types::boundary_id_t,
+ const types::boundary_id,
const Function<deal_II_space_dimension> &,
std::map<unsigned int,double> &,
const std::vector<bool> &);
void interpolate_boundary_values
(const Mapping<deal_II_dimension,deal_II_space_dimension> &,
const DH<deal_II_dimension,deal_II_space_dimension> &,
- const types::boundary_id_t,
+ const types::boundary_id,
const Function<deal_II_space_dimension> &,
ConstraintMatrix &,
const std::vector<bool> &);
template
void interpolate_boundary_values (
const DH<deal_II_dimension,deal_II_space_dimension> &,
- const types::boundary_id_t,
+ const types::boundary_id,
const Function<deal_II_space_dimension> &,
ConstraintMatrix &,
const std::vector<bool> &);
const Quadrature<deal_II_dimension-1> &,
const Function<deal_II_dimension> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
#endif
template
const Quadrature<deal_II_dimension-1> &,
const Function<deal_II_dimension> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
#if deal_II_dimension > 1
template
const hp::QCollection<deal_II_dimension-1> &,
const Function<deal_II_dimension> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
#endif
template
const hp::QCollection<deal_II_dimension-1> &,
const Function<deal_II_dimension> &,
Vector<double> &,
- const std::set<types::boundary_id_t> &);
+ const std::set<types::boundary_id> &);
(const DoFHandler<deal_II_dimension>&,
const unsigned int,
const Function<deal_II_dimension>&,
- const types::boundary_id_t,
+ const types::boundary_id,
ConstraintMatrix&,
const Mapping<deal_II_dimension>&);
template
(const hp::DoFHandler<deal_II_dimension>&,
const unsigned int,
const Function<deal_II_dimension>&,
- const types::boundary_id_t,
+ const types::boundary_id,
ConstraintMatrix&,
const hp::MappingCollection<deal_II_dimension>&);
template
(const DoFHandler<deal_II_dimension>&,
const unsigned int,
const Function<deal_II_dimension>&,
- const types::boundary_id_t,
+ const types::boundary_id,
ConstraintMatrix&,
const Mapping<deal_II_dimension>&);
template
(const hp::DoFHandler<deal_II_dimension>&,
const unsigned int,
const Function<deal_II_dimension>&,
- const types::boundary_id_t,
+ const types::boundary_id,
ConstraintMatrix&,
const hp::MappingCollection<deal_II_dimension>&);
template
void
compute_no_normal_flux_constraints (const DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id_t> &boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
ConstraintMatrix &constraints,
const Mapping<deal_II_dimension> &mapping);
template
void
compute_no_normal_flux_constraints (const hp::DoFHandler<deal_II_dimension> &dof_handler,
const unsigned int first_vector_component,
- const std::set<types::boundary_id_t> &boundary_ids,
+ const std::set<types::boundary_id> &boundary_ids,
ConstraintMatrix &constraints,
const Mapping<deal_II_dimension> &mapping);
#endif
projects / dealii-svn.git / commitdiff