<ol>
+ <li> Deprecated: The library uses functions such as CellAccessor::subdomain_id(),
+ TriaAccessor::manifold_id(), etc, but used the deviant spelling
+ TriaAccessor::boundary_indicator(), TriaAccessor::set_boundary_indicator(),
+ TriaAccessor::set_all_boundary_indicators(). These last three functions are now
+ deprecated and have been replaced by TriaAccessor::boundary_id(),
+ TriaAccessor::set_boundary_id(), and TriaAccessor::set_all_boundary_ids() for
+ consistency. Similar, Triangulation::get_boundary_indicators() has been
+ deprecated in favor of Triangulation::get_boundary_ids().
+ <br>
+ (Wolfgang Bangerth, 2015/04/11)
+ </li>
+
<li> Changed: All example programs used to have calls to set_boundary()
methods to deal with curved boundaries. These have been replaced with
the corresponding set_manifold() equivalent.
const Point<dim> face_center = cell->face(f)->center();
if (face_center[2] == 0)
- cell->face(f)->set_boundary_indicator (0);
+ cell->face(f)->set_boundary_id (0);
else if (face_center[2] == 3)
- cell->face(f)->set_boundary_indicator (1);
+ cell->face(f)->set_boundary_id (1);
else if (std::sqrt(face_center[0]*face_center[0] +
face_center[1]*face_center[1])
<
(inner_radius + outer_radius) / 2)
- cell->face(f)->set_boundary_indicator (2);
+ cell->face(f)->set_boundary_id (2);
else
- cell->face(f)->set_boundary_indicator (3);
+ cell->face(f)->set_boundary_id (3);
}
// In order to make sure that new vertices are placed correctly on
cell != triangulation.end(); ++cell)
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->face(f)->center()[dim-1] == 0)
- cell->face(f)->set_all_boundary_indicators(1);
+ cell->face(f)->set_all_boundary_ids(1);
// We then apply an initial refinement before solving for the first
((cell->face(face)->center() - transducer).norm_square() < 0.01) )
{
- cell->face(face)->set_boundary_indicator (1);
+ cell->face(face)->set_boundary_id (1);
cell->face(face)->set_manifold_id (1);
}
// For the circle part of the transducer lens, a hyper-ball object is used
// absorbing boundary conditions:
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary() &&
- (cell->face(face)->boundary_indicator() == 0) )
+ (cell->face(face)->boundary_id() == 0) )
{
of the boundary different indicators. For example, try this
immediately after calling <code>GridGenerator::hyper_cube</code>:
@code
- triangulation.begin_active()->face(0)->set_boundary_indicator(1);
+ triangulation.begin_active()->face(0)->set_boundary_id(1);
@endcode
What this does is it first asks the triangulation to
return an iterator that points to the first active cell. Of course,
dof_indices,
std::vector<types::global_dof_index>(),
true,
- cell->face(face_no)->boundary_indicator(),
+ cell->face(face_no)->boundary_id(),
cell->face(face_no)->diameter());
}
EquationData::Velocity<dim> vel_exact;
std::map<types::global_dof_index, double> boundary_values;
- std::vector<types::boundary_id> boundary_indicators;
+ std::vector<types::boundary_id> boundary_ids;
Triangulation<dim> triangulation;
std::cout << "Number of active cells: " << triangulation.n_active_cells()
<< std::endl;
- boundary_indicators = triangulation.get_boundary_indicators();
+ boundary_ids = triangulation.get_boundary_ids();
dof_handler_velocity.distribute_dofs (fe_velocity);
DoFRenumbering::boost::Cuthill_McKee (dof_handler_velocity);
vel_exact.set_component(d);
boundary_values.clear();
for (std::vector<types::boundary_id>::const_iterator
- boundaries = boundary_indicators.begin();
- boundaries != boundary_indicators.end();
+ boundaries = boundary_ids.begin();
+ boundaries != boundary_ids.end();
++boundaries)
{
switch (*boundaries)
GridGenerator::hyper_rectangle(triangulation, p1, p2);
- /* boundary_indicators:
+ /* boundary_ids:
*/
Triangulation<3>::active_cell_iterator
++face)
{
if (cell->face(face)->center()[2] == p2(2))
- cell->face(face)->set_boundary_indicator(1);
+ cell->face(face)->set_boundary_id(1);
if (cell->face(face)->center()[0] == p1(0)
|| cell->face(face)->center()[0] == p2(0)
|| cell->face(face)->center()[1] == p1(1)
|| cell->face(face)->center()[1] == p2(1))
- cell->face(face)->set_boundary_indicator(8);
+ cell->face(face)->set_boundary_id(8);
if (cell->face(face)->center()[2] == p1(2))
- cell->face(face)->set_boundary_indicator(6);
+ cell->face(face)->set_boundary_id(6);
}
}
++face)
if (cell->face(face)->at_boundary()
&&
- cell->face(face)->boundary_indicator() == 1)
+ cell->face(face)->boundary_id() == 1)
{
fe_values_face.reinit(cell, face);
cell_matrix = 0;
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary()
&&
- cell->face(face)->boundary_indicator() == 1)
+ cell->face(face)->boundary_id() == 1)
{
fe_values_face.reinit(cell, face);
cell->face(face)->get_dof_indices(dof_indices);
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary()
&&
- cell->face(face)->boundary_indicator() == 1)
+ cell->face(face)->boundary_id() == 1)
{
fe_values_face.reinit(cell, face);
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary()
- && cell->face(face)->boundary_indicator() == 1)
+ && cell->face(face)->boundary_id() == 1)
{
fe_values_face.reinit(cell, face);
for (unsigned int face = 0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary()
&&
- cell->face(face)->boundary_indicator() == 1)
+ cell->face(face)->boundary_id() == 1)
{
fe_values_face.reinit(cell, face);
if (cell->face(face)->center()[0] < 0.5 * parameters.scale
&&
cell->face(face)->center()[1] < 0.5 * parameters.scale)
- cell->face(face)->set_boundary_indicator(6);
+ cell->face(face)->set_boundary_id(6);
}
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell;
++face)
if (cell->face(face)->at_boundary() == true
- && cell->face(face)->boundary_indicator() == 6)
+ && cell->face(face)->boundary_id() == 6)
{
scratch.fe_face_values_ref.reinit(cell, face);
void LaplaceProblem::make_grid_and_dofs ()
{
GridGenerator::hyper_cube (triangulation);
- triangulation.begin_active ()->face (2)->set_boundary_indicator (1);
- triangulation.begin_active ()->face (3)->set_boundary_indicator (1);
+ triangulation.begin_active ()->face (2)->set_boundary_id (1);
+ triangulation.begin_active ()->face (3)->set_boundary_id (1);
triangulation.refine_global (5);
// The next step is to distribute the degrees of freedom and produce a
if (cell->face(f)->at_boundary()
&&
(cell->face(f)->center()[dim-1] == 1))
- cell->face(f)->set_all_boundary_indicators(1);
+ cell->face(f)->set_all_boundary_ids(1);
for (typename Triangulation<dim>::active_cell_iterator
{
if ((face_center[2] <= 2.5 || face_center[2] >= 5) &&
face_center[1] >= 3)
- cell->face(f)->set_boundary_indicator(8);
+ cell->face(f)->set_boundary_id(8);
if (face_center[2] >= 2.5 &&
face_center[2] <= 5
&& face_center[1] >= 3)
- cell->face(f)->set_boundary_indicator(9);
+ cell->face(f)->set_boundary_id(9);
}
}
picture with the one of the coarse mesh). What is happening is that we
are only telling the triangulation to use these geometry objects for
the <i>faces</i> but not for the adjacent <i>edges</i> as well. This is
-easily fixed by using the function TriaAccessor::set_all_boundary_indicators()
-instead of TriaAccessor::set_boundary_indicator() used above. With this change,
+easily fixed by using the function TriaAccessor::set_all_boundary_ids()
+instead of TriaAccessor::set_boundary_id() used above. With this change,
the grid now looks like this:
<img
{
if ((face_center[2] < 2.5 || face_center[2] > 5)
&& face_center[1] >= 3)
- cell->face(f)->set_all_boundary_indicators(8);
+ cell->face(f)->set_all_boundary_ids(8);
if (face_center[2] > 2.5 && face_center[2] < 5
&& face_center[1] >= 3)
- cell->face(f)->set_all_boundary_indicators(9);
+ cell->face(f)->set_all_boundary_ids(9);
}
}
}
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
{
if (cell->face(face)->at_boundary())
- boundary_count[cell->face(face)->boundary_indicator()]++;
+ boundary_count[cell->face(face)->boundary_id()]++;
}
}
if (cell->face(face)->at_boundary()
&&
- (cell->face(face)->boundary_indicator() == 1))
+ (cell->face(face)->boundary_id() == 1))
{
const double neumann_value =
- scratch.exact_solution.gradient (quadrature_point) * normal
if ((std::fabs(cell->face(face)->center()(0) - (-1)) < 1e-12)
||
(std::fabs(cell->face(face)->center()(1) - (-1)) < 1e-12))
- cell->face(face)->set_boundary_indicator (1);
+ cell->face(face)->set_boundary_id (1);
}
// @sect4{HDG::run}
if (cell->face(f)->at_boundary())
{
if ((cell->face(f)->center()[0]==0.) || (cell->face(f)->center()[0]==5.))
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
else
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
}
// Next, we set up the linear systems and fill them with content so that
for (Triangulation<3>::active_cell_iterator cell=triangulation.begin_active();
cell!=triangulation.end(); ++cell)
for (unsigned int f=0; f<GeometryInfo<3>::faces_per_cell; ++f)
- if (cell->face(f)->boundary_indicator() == 5)
+ if (cell->face(f)->boundary_id() == 5)
{
cell->set_refine_flag ();
break;
for (unsigned int face_number=0; face_number<GeometryInfo<dim>::faces_per_cell; ++face_number)
if (cell->face(face_number)->at_boundary()
&&
- (cell->face(face_number)->boundary_indicator() == 1))
+ (cell->face(face_number)->boundary_id() == 1))
{
// If we came into here, then we have found an external face
// belonging to Gamma2. Next, we have to compute the values of
if ((std::fabs(cell->face(face_number)->center()(0) - (-1)) < 1e-12)
||
(std::fabs(cell->face(face_number)->center()(1) - (-1)) < 1e-12))
- cell->face(face_number)->set_boundary_indicator (1);
+ cell->face(face_number)->set_boundary_id (1);
}
else
refine_grid ();
* #include <deal.II/base/std_cxx11/bind.h>
*
* template <int dim>
- * void set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation)
+ * void set_boundary_ids (parallel::distributed::Triangulation<dim> &triangulation)
* {
* ... set boundary indicators on the triangulation object ...
* }
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx11::bind (&set_boundary_indicators<dim>,
+ * (std_cxx11::bind (&set_boundary_ids<dim>,
* std_cxx11::ref(coarse_grid)));
*
* }
* argument but permanently fix this one argument to a reference to the
* coarse grid triangulation. After each refinement step, the
* triangulation will then call the object so created which will in turn
- * call <code>set_boundary_indicators<dim></code> with the reference to
+ * call <code>set_boundary_ids<dim></code> with the reference to
* the coarse grid as argument.
*
* This approach can be generalized. In the example above, we have used a
* that this function is in fact a member function of the class that
* generates the mesh, for example because it needs to access run-time
* parameters. This can be achieved as follows: assuming the
- * <code>set_boundary_indicators()</code> function has been declared as a
+ * <code>set_boundary_ids()</code> function has been declared as a
* (non-static, but possibly private) member function of the
* <code>MyClass</code> class, then the following will work:
* @code
* template <int dim>
* void
* MyClass<dim>::
- * set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
+ * set_boundary_ids (parallel::distributed::Triangulation<dim> &triangulation) const
* {
* ... set boundary indicators on the triangulation object ...
* }
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx11::bind (&MyGeometry<dim>::set_boundary_indicators,
+ * (std_cxx11::bind (&MyGeometry<dim>::set_boundary_ids,
* std_cxx11::cref(*this),
* std_cxx11::ref(coarse_grid)));
* }
* @endcode
* Here, like any other member function,
- * <code>set_boundary_indicators</code> implicitly takes a pointer or
+ * <code>set_boundary_ids</code> implicitly takes a pointer or
* reference to the object it belongs to as first argument.
* <code>std::bind</code> again creates an object that can be called like
* a global function with no arguments, and this object in turn calls
- * <code>set_boundary_indicators</code> with a pointer to the current
+ * <code>set_boundary_ids</code> with a pointer to the current
* object and a reference to the triangulation to work on. Note that
* because the <code>create_coarse_mesh</code> function is declared as
* <code>const</code>, it is necessary that the
- * <code>set_boundary_indicators</code> function is also declared
+ * <code>set_boundary_ids</code> function is also declared
* <code>const</code>.
*
* <b>Note:</b>For reasons that have to do with the way the
* function.
*/
types::global_dof_index
- n_boundary_dofs (const FunctionMap &boundary_indicators) const;
+ n_boundary_dofs (const FunctionMap &boundary_ids) const;
/**
* Same function, but with different data type of the argument, which is
* here simply a list of the boundary indicators under consideration.
*/
types::global_dof_index
- n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const;
+ n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const;
/**
* Access to an object informing of the block structure of the dof handler.
template <class DH, class SparsityPattern>
void
make_boundary_sparsity_pattern (const DH &dof,
- const typename FunctionMap<DH::space_dimension>::type &boundary_indicators,
+ const typename FunctionMap<DH::space_dimension>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SparsityPattern &sparsity);
* @ref GlossFaceOrientation "standard orientation".
*
* Instead of defining a 'first' and 'second' boundary with the help of two
- * boundary_indicators this function defines a 'left' boundary as all faces
+ * boundary_ids this function defines a 'left' boundary as all faces
* with local face index <code>2*dimension</code> and boundary indicator @p
* b_id and, similarly, a 'right' boundary consisting of all face with local
* face index <code>2*dimension+1</code> and boundary indicator @p b_id.
* of freedom is at the boundary and belongs to one of the selected
* components, and @p false otherwise. The function is used in step-15.
*
- * By specifying the @p boundary_indicator variable, you can select which
+ * By specifying the @p boundary_id variable, you can select which
* boundary indicators the faces have to have on which the degrees of
* freedom are located that shall be extracted. If it is an empty list, then
* all boundary indicators are accepted.
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
* indicators, depending on the values of the @p component_mask and @p
- * boundary_indicators arguments).
- * @param boundary_indicators If empty, this function extracts the indices
+ * boundary_ids arguments).
+ * @param boundary_ids If empty, this function extracts the indices
* of the degrees of freedom for all parts of the boundary. If it is a non-
* empty list, then the function only considers boundary faces with the
* boundary indicators listed in this argument.
extract_boundary_dofs (const DH &dof_handler,
const ComponentMask &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* This function does the same as the previous one but it returns its result
* contain the indices of degrees of freedom that are located on the
* boundary (and correspond to the selected vector components and boundary
* indicators, depending on the values of the @p component_mask and @p
- * boundary_indicators arguments).
- * @param boundary_indicators If empty, this function extracts the indices
+ * boundary_ids arguments).
+ * @param boundary_ids If empty, this function extracts the indices
* of the degrees of freedom for all parts of the boundary. If it is a non-
* empty list, then the function only considers boundary faces with the
* boundary indicators listed in this argument.
extract_boundary_dofs (const DH &dof_handler,
const ComponentMask &component_mask,
IndexSet &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* This function is similar to the extract_boundary_dofs() function but it
extract_dofs_with_support_on_boundary (const DH &dof_handler,
const ComponentMask &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Extract a vector that represents the constant modes of the DoFHandler for
template <class DH>
void
map_dof_to_boundary_indices (const DH &dof_handler,
- const std::set<types::boundary_id> &boundary_indicators,
+ const std::set<types::boundary_id> &boundary_ids,
std::vector<types::global_dof_index> &mapping);
/**
* A variant of this function with different arguments is used in step-36.
*
* @param dof The DoFHandler to work on.
- * @param boundary_indicator The indicator of that part of the boundary for
+ * @param boundary_id The indicator of that part of the boundary for
* which constraints should be computed. If this number equals
* numbers::invalid_boundary_id then all boundaries of the domain will be
* treated.
template <int dim, int spacedim, template <int, int> class DH>
void
make_zero_boundary_constraints (const DH<dim,spacedim> &dof,
- const types::boundary_id boundary_indicator,
+ const types::boundary_id boundary_id,
ConstraintMatrix &zero_boundary_constraints,
const ComponentMask &component_mask = ComponentMask());
* Create a coordinate-parallel brick from the two diagonally opposite
* corner points @p p1 and @p p2.
*
- * If the @p colorize flag is set, the @p boundary_indicators of the
+ * If the @p colorize flag is set, the @p boundary_ids of the
* surfaces are assigned, such that the lower one in @p x-direction is 0,
* the upper one is 1. The indicators for the surfaces in @p y-direction are
* 2 and 3, the ones for @p z are 4 and 5. Additionally, material ids are
* a list of integers denoting the number of subdivisions in each coordinate
* direction.
*
- * If the @p colorize flag is set, the @p boundary_indicators of the
+ * If the @p colorize flag is set, the @p boundary_ids of the
* surfaces are assigned, such that the lower one in @p x-direction is 0,
* the upper one is 1 (the left and the right vertical face). The indicators
* for the surfaces in @p y-direction are 2 and 3, the ones for @p z are 4
* @ref GlossFaceOrientation "standard orientation".
*
* Instead of defining a 'first' and 'second' boundary with the help of two
- * boundary_indicators this function defines a 'left' boundary as all faces
+ * boundary_ids this function defines a 'left' boundary as all faces
* with local face index <code>2*dimension</code> and boundary indicator @p
* b_id and, similarly, a 'right' boundary consisting of all face with local
* face index <code>2*dimension+1</code> and boundary indicator @p b_id.
* function.
*/
types::global_dof_index
- n_boundary_dofs (const FunctionMap &boundary_indicators) const;
+ n_boundary_dofs (const FunctionMap &boundary_ids) const;
/**
* Same function, but with different data type of the argument, which is
* here simply a list of the boundary indicators under consideration.
*/
types::global_dof_index
- n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const;
+ n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const;
/**
* Return the number of degrees of freedom that belong to this process.
*
* The parameter @p function_map provides a list of boundary indicators to
* be handled by this function and corresponding boundary value functions.
- * The keys of this map correspond to the number @p boundary_indicator of
+ * The keys of this map correspond to the number @p boundary_id of
* the face. numbers::internal_face_boundary_id is an illegal value for
* this key since it is reserved for interior faces.
*
* @ref constraints.
*
* The parameter @p boundary_component corresponds to the number @p
- * boundary_indicator of the face.
+ * boundary_id of the face.
*
* The flags in the last parameter, @p component_mask denote which
* components of the finite element space shall be interpolated. If it is
* $z$-component.
*
* The parameter @p boundary_component corresponds to the number @p
- * boundary_indicator of the face. numbers::internal_face_boundary_id is an
+ * boundary_id of the face. numbers::internal_face_boundary_id is an
* illegal value, since it is reserved for interior faces.
*
* The last argument is denoted to compute the normal vector $\vec{n}$ at
* that are ordered in the same way as we usually order the coordinate directions,
* i.e. $x$-, $y$-, and finally $z$-component.
*
- * The parameter @p boundary_component corresponds to the number @p boundary_indicator
+ * The parameter @p boundary_component corresponds to the number @p boundary_id
* of the face. numbers::internal_face_boundary_id is an illegal value, since it is
* reserved for interior faces.
*
* $z$-component.
*
* The parameter @p boundary_component corresponds to the @p
- * boundary_indicator of the faces where the boundary conditions are
+ * boundary_id of the faces where the boundary conditions are
* applied. numbers::internal_face_boundary_id is an illegal value, since it
* is reserved for interior faces. The @p mapping is used to compute the
* normal vector $\vec{n}$ at the boundary points.
const Quadrature<dim-1> &q,
const Function<spacedim,double> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Calls the create_boundary_right_hand_side() function, see above, with
const Quadrature<dim-1> &q,
const Function<spacedim,double> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Same as the set of functions above, but for hp objects.
const hp::QCollection<dim-1> &q,
const Function<spacedim,double> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Calls the create_boundary_right_hand_side() function, see above, with a
const hp::QCollection<dim-1> &q,
const Function<spacedim,double> &rhs,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
//@}
/**
// function to hold on
// all parts of the boundary
const std::vector<types::boundary_id>
- used_boundary_indicators = dof.get_tria().get_boundary_indicators();
+ used_boundary_ids = dof.get_tria().get_boundary_ids();
typename FunctionMap<spacedim>::type boundary_functions;
- for (unsigned int i=0; i<used_boundary_indicators.size(); ++i)
- boundary_functions[used_boundary_indicators[i]] = &function;
+ for (unsigned int i=0; i<used_boundary_ids.size(); ++i)
+ boundary_functions[used_boundary_ids[i]] = &function;
project_boundary_values (mapping, dof, boundary_functions, q_boundary,
boundary_values);
}
const Quadrature<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
for (; cell!=endc; ++cell)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary () &&
- (boundary_indicators.empty() ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
+ (boundary_ids.empty() ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
!=
- boundary_indicators.end())))
+ boundary_ids.end())))
{
fe_values.reinit(cell, face);
for (; cell!=endc; ++cell)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary () &&
- (boundary_indicators.empty() ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
+ (boundary_ids.empty() ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
!=
- boundary_indicators.end())))
+ boundary_ids.end())))
{
fe_values.reinit(cell, face);
const Quadrature<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(StaticMappingQ1<dim>::mapping, dof_handler,
quadrature,
rhs_function, rhs_vector,
- boundary_indicators);
+ boundary_ids);
}
const hp::QCollection<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
const hp::FECollection<dim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
for (; cell!=endc; ++cell)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary () &&
- (boundary_indicators.empty() ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
+ (boundary_ids.empty() ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
!=
- boundary_indicators.end())))
+ boundary_ids.end())))
{
x_fe_values.reinit(cell, face);
for (; cell!=endc; ++cell)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (cell->face(face)->at_boundary () &&
- (boundary_indicators.empty() ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
+ (boundary_ids.empty() ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
!=
- boundary_indicators.end())))
+ boundary_ids.end())))
{
x_fe_values.reinit(cell, face);
const hp::QCollection<dim-1> &quadrature,
const Function<spacedim> &rhs_function,
Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(hp::StaticMappingQ1<dim>::mapping_collection,
dof_handler, quadrature,
rhs_function, rhs_vector,
- boundary_indicators);
+ boundary_ids);
}
direction<GeometryInfo<dim>::faces_per_cell; ++direction)
if (cell->at_boundary(direction)
&&
- (function_map.find(cell->face(direction)->boundary_indicator()) != function_map.end()))
+ (function_map.find(cell->face(direction)->boundary_id()) != function_map.end()))
{
const Function<DH::space_dimension> &boundary_function
- = *function_map.find(cell->face(direction)->boundary_indicator())->second;
+ = *function_map.find(cell->face(direction)->boundary_id())->second;
// get the FE corresponding to this
// cell
}
const typename DH::face_iterator face = cell->face(face_no);
- const types::boundary_id boundary_component = face->boundary_indicator();
+ const types::boundary_id boundary_component = face->boundary_id();
// see if this face is part of the boundaries for which we are
// supposed to do something, and also see if the finite element
for (; cell != dof_handler.end (); ++cell)
if (cell->at_boundary () && cell->is_locally_owned ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// if the FE is a
// FE_Nothing object
for (; cell != dof_handler.end (); ++cell)
if (cell->at_boundary () && cell->is_locally_owned ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// if the FE is a
// FE_Nothing object
for (; cell != dof_handler.end (); ++cell)
if (cell->at_boundary () && cell->is_locally_owned ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// if the FE is a FE_Nothing object there is no work to do
if (dynamic_cast<const FE_Nothing<dim>*> (&cell->get_fe ()) != 0)
for (; cell != dof_handler.end (); ++cell)
if (cell->at_boundary () && cell->is_locally_owned ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// if the FE is a FE_Nothing object there is no work to do
if (dynamic_cast<const FE_Nothing<dim>*> (&cell->get_fe ()) != 0)
{
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
{
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// If the FE is an FE_Nothing object there is no work to do
if (dynamic_cast<const FE_Nothing<dim>*> (&cell->get_fe ()) != 0)
{
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
{
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// If the FE is an FE_Nothing object there is no work to do
if (dynamic_cast<const FE_Nothing<dim>*> (&cell->get_fe ()) != 0)
cell != dof_handler.end (); ++cell)
if (cell->at_boundary ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// if the FE is a
// FE_Nothing object
cell != dof_handler.end (); ++cell)
if (cell->at_boundary ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// This is only
// implemented, if the
cell != dof_handler.end (); ++cell)
if (cell->at_boundary ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// This is only
// implemented, if the
cell != dof_handler.end (); ++cell)
if (cell->at_boundary ())
for (unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell; ++face)
- if (cell->face (face)->boundary_indicator () == boundary_component)
+ if (cell->face (face)->boundary_id () == boundary_component)
{
// This is only
// implemented, if the
if (!cell->is_artificial())
for (unsigned int face_no=0; face_no < GeometryInfo<dim>::faces_per_cell;
++face_no)
- if ((b_id=boundary_ids.find(cell->face(face_no)->boundary_indicator()))
+ if ((b_id=boundary_ids.find(cell->face(face_no)->boundary_id()))
!= boundary_ids.end())
{
const FiniteElement<dim> &fe = cell->get_fe ();
if (!cell->is_artificial())
for (unsigned int face_no=0; face_no < GeometryInfo<dim>::faces_per_cell;
++face_no)
- if ((b_id=boundary_ids.find(cell->face(face_no)->boundary_indicator()))
+ if ((b_id=boundary_ids.find(cell->face(face_no)->boundary_id()))
!= boundary_ids.end())
{
const FiniteElement<dim> &fe = cell->get_fe();
template <>
-types::global_dof_index DoFHandler<1>::n_boundary_dofs (const FunctionMap &boundary_indicators) const
+types::global_dof_index DoFHandler<1>::n_boundary_dofs (const FunctionMap &boundary_ids) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (FunctionMap::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (FunctionMap::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((i->first == 0) || (i->first == 1),
ExcInvalidBoundaryIndicator());
- return boundary_indicators.size()*get_fe().dofs_per_vertex;
+ return boundary_ids.size()*get_fe().dofs_per_vertex;
}
template <>
-types::global_dof_index DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
+types::global_dof_index DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (std::set<types::boundary_id>::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
- return boundary_indicators.size()*get_fe().dofs_per_vertex;
+ return boundary_ids.size()*get_fe().dofs_per_vertex;
}
template <>
-types::global_dof_index DoFHandler<1,2>::n_boundary_dofs (const FunctionMap &boundary_indicators) const
+types::global_dof_index DoFHandler<1,2>::n_boundary_dofs (const FunctionMap &boundary_ids) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (FunctionMap::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (FunctionMap::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((i->first == 0) || (i->first == 1),
ExcInvalidBoundaryIndicator());
- return boundary_indicators.size()*get_fe().dofs_per_vertex;
+ return boundary_ids.size()*get_fe().dofs_per_vertex;
}
template <>
-types::global_dof_index DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
+types::global_dof_index DoFHandler<1,2>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (std::set<types::boundary_id>::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
- return boundary_indicators.size()*get_fe().dofs_per_vertex;
+ return boundary_ids.size()*get_fe().dofs_per_vertex;
}
template<int dim, int spacedim>
types::global_dof_index
-DoFHandler<dim,spacedim>::n_boundary_dofs (const FunctionMap &boundary_indicators) const
+DoFHandler<dim,spacedim>::n_boundary_dofs (const FunctionMap &boundary_ids) const
{
- Assert (boundary_indicators.find(numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find(numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
std::set<int> boundary_dofs;
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->at_boundary(f)
&&
- (boundary_indicators.find(cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end()))
+ (boundary_ids.find(cell->face(f)->boundary_id()) !=
+ boundary_ids.end()))
{
cell->face(f)->get_dof_indices (dofs_on_face);
for (unsigned int i=0; i<dofs_per_face; ++i)
template<int dim, int spacedim>
types::global_dof_index
-DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
+DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
- Assert (boundary_indicators.find (numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
std::set<int> boundary_dofs;
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->at_boundary(f)
&&
- (std::find (boundary_indicators.begin(),
- boundary_indicators.end(),
- cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end()))
+ (std::find (boundary_ids.begin(),
+ boundary_ids.end(),
+ cell->face(f)->boundary_id()) !=
+ boundary_ids.end()))
{
cell->face(f)->get_dof_indices (dofs_on_face);
for (unsigned int i=0; i<dofs_per_face; ++i)
extract_boundary_dofs (const DH &dof_handler,
const ComponentMask &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
Assert ((dynamic_cast<const parallel::distributed::Triangulation<DH::dimension,DH::space_dimension>*>
(&dof_handler.get_tria())
IndexSet indices;
extract_boundary_dofs (dof_handler, component_mask,
- indices, boundary_indicators);
+ indices, boundary_ids);
// clear and reset array by default values
selected_dofs.clear ();
extract_boundary_dofs (const DH &dof_handler,
const ComponentMask &component_mask,
IndexSet &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
Assert (component_mask.represents_n_components(n_components(dof_handler)),
ExcMessage ("Component mask has invalid size."));
- Assert (boundary_indicators.find (numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
const unsigned int dim=DH::dimension;
// let's see whether we have to check for certain boundary indicators
// or whether we can accept all
- const bool check_boundary_indicator = (boundary_indicators.size() != 0);
+ const bool check_boundary_id = (boundary_ids.size() != 0);
// also see whether we have to check whether a certain vector component
// is selected, or all
for (unsigned int face=0;
face<GeometryInfo<DH::dimension>::faces_per_cell; ++face)
if (cell->at_boundary(face))
- if (! check_boundary_indicator ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
- != boundary_indicators.end()))
+ if (! check_boundary_id ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
+ != boundary_ids.end()))
{
const FiniteElement<DH::dimension, DH::space_dimension> &fe = cell->get_fe();
extract_dofs_with_support_on_boundary (const DH &dof_handler,
const ComponentMask &component_mask,
std::vector<bool> &selected_dofs,
- const std::set<types::boundary_id> &boundary_indicators)
+ const std::set<types::boundary_id> &boundary_ids)
{
Assert (component_mask.represents_n_components (n_components(dof_handler)),
ExcMessage ("This component mask has the wrong size."));
- Assert (boundary_indicators.find (numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
// let's see whether we have to check for certain boundary indicators
// or whether we can accept all
- const bool check_boundary_indicator = (boundary_indicators.size() != 0);
+ const bool check_boundary_id = (boundary_ids.size() != 0);
// also see whether we have to check whether a certain vector component
// is selected, or all
for (unsigned int face=0;
face<GeometryInfo<DH::dimension>::faces_per_cell; ++face)
if (cell->at_boundary(face))
- if (! check_boundary_indicator ||
- (boundary_indicators.find (cell->face(face)->boundary_indicator())
- != boundary_indicators.end()))
+ if (! check_boundary_id ||
+ (boundary_ids.find (cell->face(face)->boundary_id())
+ != boundary_ids.end()))
{
const FiniteElement<DH::dimension, DH::space_dimension> &fe = cell->get_fe();
template <class DH>
void map_dof_to_boundary_indices (
const DH &dof_handler,
- const std::set<types::boundary_id> &boundary_indicators,
+ const std::set<types::boundary_id> &boundary_ids,
std::vector<types::global_dof_index> &mapping)
{
- Assert (boundary_indicators.find (numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
mapping.clear ();
DH::invalid_dof_index);
// return if there is nothing to do
- if (boundary_indicators.size() == 0)
+ if (boundary_ids.size() == 0)
return;
std::vector<types::global_dof_index> dofs_on_face;
endc = dof_handler.end();
for (; cell!=endc; ++cell)
for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
- if (boundary_indicators.find (cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end())
+ if (boundary_ids.find (cell->face(f)->boundary_id()) !=
+ boundary_ids.end())
{
const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
dofs_on_face.resize (dofs_per_face);
}
AssertDimension (next_boundary_index,
- dof_handler.n_boundary_dofs (boundary_indicators));
+ dof_handler.n_boundary_dofs (boundary_ids));
}
namespace internal
template <int dim, int spacedim, template <int,int> class DH>
void
make_zero_boundary_constraints (const DH<dim, spacedim> &dof,
- const types::boundary_id boundary_indicator,
+ const types::boundary_id boundary_id,
ConstraintMatrix &zero_boundary_constraints,
const ComponentMask &component_mask)
{
// boundary id property
if (face->at_boundary ()
&&
- ((boundary_indicator == numbers::invalid_boundary_id)
+ ((boundary_id == numbers::invalid_boundary_id)
||
- (face->boundary_indicator() == boundary_indicator)))
+ (face->boundary_id() == boundary_id)))
{
// get indices and physical location on this face
face_dofs.resize (fe.dofs_per_face);
{
// there are only 2 boundary indicators in 1d, so it is no
// performance problem to call the other function
- typename DH::FunctionMap boundary_indicators;
- boundary_indicators[0] = 0;
- boundary_indicators[1] = 0;
+ typename DH::FunctionMap boundary_ids;
+ boundary_ids[0] = 0;
+ boundary_ids[1] = 0;
make_boundary_sparsity_pattern<DH, SparsityPattern> (dof,
- boundary_indicators,
+ boundary_ids,
dof_to_boundary_mapping,
sparsity);
return;
template <class DH, class SparsityPattern>
void make_boundary_sparsity_pattern (
const DH &dof,
- const typename FunctionMap<DH::space_dimension>::type &boundary_indicators,
+ const typename FunctionMap<DH::space_dimension>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SparsityPattern &sparsity)
{
for (unsigned int direction=0; direction<2; ++direction)
{
// if this boundary is not requested, then go on with next one
- if (boundary_indicators.find(direction) ==
- boundary_indicators.end())
+ if (boundary_ids.find(direction) ==
+ boundary_ids.end())
continue;
// find active cell at that boundary: first go to left/right,
const types::global_dof_index n_dofs = dof.n_dofs();
AssertDimension (dof_to_boundary_mapping.size(), n_dofs);
- Assert (boundary_indicators.find(numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find(numbers::internal_face_boundary_id) == boundary_ids.end(),
typename DH::ExcInvalidBoundaryIndicator());
- Assert (sparsity.n_rows() == dof.n_boundary_dofs (boundary_indicators),
- ExcDimensionMismatch (sparsity.n_rows(), dof.n_boundary_dofs (boundary_indicators)));
- Assert (sparsity.n_cols() == dof.n_boundary_dofs (boundary_indicators),
- ExcDimensionMismatch (sparsity.n_cols(), dof.n_boundary_dofs (boundary_indicators)));
+ Assert (sparsity.n_rows() == dof.n_boundary_dofs (boundary_ids),
+ ExcDimensionMismatch (sparsity.n_rows(), dof.n_boundary_dofs (boundary_ids)));
+ Assert (sparsity.n_cols() == dof.n_boundary_dofs (boundary_ids),
+ ExcDimensionMismatch (sparsity.n_cols(), dof.n_boundary_dofs (boundary_ids)));
#ifdef DEBUG
if (sparsity.n_rows() != 0)
{
endc = dof.end();
for (; cell!=endc; ++cell)
for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
- if (boundary_indicators.find(cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end())
+ if (boundary_ids.find(cell->face(f)->boundary_id()) !=
+ boundary_ids.end())
{
const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
dofs_on_this_face.resize (dofs_per_face);
template void
DoFTools::make_boundary_sparsity_pattern<DoFHandler<deal_II_dimension>,SP>
(const DoFHandler<deal_II_dimension>& dof,
- const FunctionMap<deal_II_dimension>::type &boundary_indicators,
+ const FunctionMap<deal_II_dimension>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
template void
DoFTools::make_boundary_sparsity_pattern<hp::DoFHandler<deal_II_dimension>,SP>
(const hp::DoFHandler<deal_II_dimension>& dof,
- const FunctionMap<deal_II_dimension>::type &boundary_indicators,
+ const FunctionMap<deal_II_dimension>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
template void
DoFTools::make_boundary_sparsity_pattern<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1>,SP>
(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1>& dof,
- const FunctionMap<deal_II_dimension+1>::type &boundary_indicators,
+ const FunctionMap<deal_II_dimension+1>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
#endif
template void
DoFTools::make_boundary_sparsity_pattern<DoFHandler<deal_II_dimension,deal_II_dimension+1>,SP>
(const DoFHandler<deal_II_dimension,deal_II_dimension+1>& dof,
- const FunctionMap<deal_II_dimension+1>::type &boundary_indicators,
+ const FunctionMap<deal_II_dimension+1>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
//template void
//DoFTools::make_boundary_sparsity_pattern<hp::DoFHandler<deal_II_dimension,deal_II_dimension+1>,SP>
//(const hp::DoFHandler<deal_II_dimension,deal_II_dimension+1>& dof,
- // const FunctionMap<deal_II_dimension+1>::type &boundary_indicators,
+ // const FunctionMap<deal_II_dimension+1>::type &boundary_ids,
// const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
// SP &sparsity);
template void
DoFTools::make_boundary_sparsity_pattern<DoFHandler<1,3>,SP>
(const DoFHandler<1,3>& dof,
- const FunctionMap<3>::type &boundary_indicators,
+ const FunctionMap<3>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
template void
DoFTools::make_boundary_sparsity_pattern<hp::DoFHandler<1,3>,SP>
(const hp::DoFHandler<1,3>& dof,
- const FunctionMap<3>::type &boundary_indicators,
+ const FunctionMap<3>::type &boundary_ids,
const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
SP &sparsity);
// first get the normal vectors at the two vertices of this line
// from the boundary description
const Boundary<dim> &boundary
- = line->get_triangulation().get_boundary(line->boundary_indicator());
+ = line->get_triangulation().get_boundary(line->boundary_id());
Boundary<dim>::FaceVertexNormals face_vertex_normals;
boundary.get_normals_at_vertices (line, face_vertex_normals);
const typename Triangulation<dim,spacedim>::cell_iterator
cell = tria.begin();
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- cell->face(f)->set_boundary_indicator (f);
+ cell->face(f)->set_boundary_id (f);
}
}
endface = tria.end_face();
for (; face!=endface; ++face)
{
- if (face->boundary_indicator() == 0)
+ if (face->boundary_id() == 0)
{
const Point<dim> center (face->center());
if (std::abs(center(0)-p1[0]) < epsilon)
- face->set_boundary_indicator(0);
+ face->set_boundary_id(0);
else if (std::abs(center(0) - p2[0]) < epsilon)
- face->set_boundary_indicator(1);
+ face->set_boundary_id(1);
else if (dim > 1 && std::abs(center(1) - p1[1]) < epsilon)
- face->set_boundary_indicator(2);
+ face->set_boundary_id(2);
else if (dim > 1 && std::abs(center(1) - p2[1]) < epsilon)
- face->set_boundary_indicator(3);
+ face->set_boundary_id(3);
else if (dim > 2 && std::abs(center(2) - p1[2]) < epsilon)
- face->set_boundary_indicator(4);
+ face->set_boundary_id(4);
else if (dim > 2 && std::abs(center(2) - p2[2]) < epsilon)
- face->set_boundary_indicator(5);
+ face->set_boundary_id(5);
else
// triangulation says it
// is on the boundary,
cell != tria.end (); ++cell)
{
Assert(cell->face(2)->at_boundary(), ExcInternalError());
- cell->face (2)->set_all_boundary_indicators (1);
+ cell->face (2)->set_all_boundary_ids (1);
}
}
Triangulation<3>::cell_iterator cell = tria.begin();
Assert (cell->face(4)->at_boundary(), ExcInternalError());
- cell->face(4)->set_all_boundary_indicators(1);
+ cell->face(4)->set_all_boundary_ids(1);
++cell;
Assert (cell->face(2)->at_boundary(), ExcInternalError());
- cell->face(2)->set_all_boundary_indicators(1);
+ cell->face(2)->set_all_boundary_ids(1);
++cell;
Assert (cell->face(2)->at_boundary(), ExcInternalError());
- cell->face(2)->set_all_boundary_indicators(1);
+ cell->face(2)->set_all_boundary_ids(1);
++cell;
Assert (cell->face(0)->at_boundary(), ExcInternalError());
- cell->face(0)->set_all_boundary_indicators(1);
+ cell->face(0)->set_all_boundary_ids(1);
++cell;
Assert (cell->face(2)->at_boundary(), ExcInternalError());
- cell->face(2)->set_all_boundary_indicators(1);
+ cell->face(2)->set_all_boundary_ids(1);
++cell;
Assert (cell->face(0)->at_boundary(), ExcInternalError());
- cell->face(0)->set_all_boundary_indicators(1);
+ cell->face(0)->set_all_boundary_ids(1);
}
else if (tria.n_cells() == 12)
{
cell != tria.end(); ++cell)
{
Assert (cell->face(5)->at_boundary(), ExcInternalError());
- cell->face(5)->set_all_boundary_indicators(1);
+ cell->face(5)->set_all_boundary_ids(1);
}
}
else if (tria.n_cells() == 96)
cell != tria.end(); ++cell)
if (cell->face(5)->at_boundary())
{
- cell->face(5)->set_all_boundary_indicators(1);
+ cell->face(5)->set_all_boundary_ids(1);
++count;
}
Assert (count == 48, ExcInternalError());
double radius = cell->face(f)->center().norm() - center.norm();
if (std::fabs(cell->face(f)->center()(0)) < eps ) // x = 0 set boundary 2
{
- cell->face(f)->set_boundary_indicator(2);
+ cell->face(f)->set_boundary_id(2);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
if (cell->face(f)->line(j)->at_boundary())
if (std::fabs(cell->face(f)->line(j)->vertex(0).norm() - cell->face(f)->line(j)->vertex(1).norm()) > eps)
- cell->face(f)->line(j)->set_boundary_indicator(2);
+ cell->face(f)->line(j)->set_boundary_id(2);
}
else if (std::fabs(cell->face(f)->center()(1)) < eps) // y = 0 set boundary 3
{
- cell->face(f)->set_boundary_indicator(3);
+ cell->face(f)->set_boundary_id(3);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
if (cell->face(f)->line(j)->at_boundary())
if (std::fabs(cell->face(f)->line(j)->vertex(0).norm() - cell->face(f)->line(j)->vertex(1).norm()) > eps)
- cell->face(f)->line(j)->set_boundary_indicator(3);
+ cell->face(f)->line(j)->set_boundary_id(3);
}
else if (std::fabs(cell->face(f)->center()(2)) < eps ) // z = 0 set boundary 4
{
- cell->face(f)->set_boundary_indicator(4);
+ cell->face(f)->set_boundary_id(4);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
if (cell->face(f)->line(j)->at_boundary())
if (std::fabs(cell->face(f)->line(j)->vertex(0).norm() - cell->face(f)->line(j)->vertex(1).norm()) > eps)
- cell->face(f)->line(j)->set_boundary_indicator(4);
+ cell->face(f)->line(j)->set_boundary_id(4);
}
else if (radius < middle) // inner radius set boundary 0
{
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
if (cell->face(f)->line(j)->at_boundary())
if (std::fabs(cell->face(f)->line(j)->vertex(0).norm() - cell->face(f)->line(j)->vertex(1).norm()) < eps)
- cell->face(f)->line(j)->set_boundary_indicator(0);
+ cell->face(f)->line(j)->set_boundary_id(0);
}
else if (radius > middle) // outer radius set boundary 1
{
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
if (cell->face(f)->line(j)->at_boundary())
if (std::fabs(cell->face(f)->line(j)->vertex(0).norm() - cell->face(f)->line(j)->vertex(1).norm()) < eps)
- cell->face(f)->line(j)->set_boundary_indicator(1);
+ cell->face(f)->line(j)->set_boundary_id(1);
}
else
AssertThrow (false, ExcInternalError());
{
Point<2> cell_center = cell->center();
for (unsigned int f=0; f<GeometryInfo<2>::faces_per_cell; ++f)
- if (cell->face(f)->boundary_indicator() == 0)
+ if (cell->face(f)->boundary_id() == 0)
{
Point<2> face_center = cell->face(f)->center();
for (unsigned int i=0; i<2; ++i)
{
if (face_center[i]<cell_center[i]-eps)
- cell->face(f)->set_boundary_indicator(i*2);
+ cell->face(f)->set_boundary_id(i*2);
if (face_center[i]>cell_center[i]+eps)
- cell->face(f)->set_boundary_indicator(i*2+1);
+ cell->face(f)->set_boundary_id(i*2+1);
}
}
}
{
Point<dim> cell_center = cell->center();
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- if (cell->face(f)->boundary_indicator() == 0)
+ if (cell->face(f)->boundary_id() == 0)
{
Point<dim> face_center = cell->face(f)->center();
for (unsigned int i=0; i<dim; ++i)
{
if (face_center[i]<cell_center[i]-eps)
- cell->face(f)->set_boundary_indicator(i*2);
+ cell->face(f)->set_boundary_id(i*2);
if (face_center[i]>cell_center[i]+eps)
- cell->face(f)->set_boundary_indicator(i*2+1);
+ cell->face(f)->set_boundary_id(i*2+1);
}
}
}
if (colorize)
{
Triangulation<2>::cell_iterator cell = tria.begin();
- cell->face(1)->set_boundary_indicator(1);
+ cell->face(1)->set_boundary_id(1);
++cell;
- cell->face(3)->set_boundary_indicator(2);
+ cell->face(3)->set_boundary_id(2);
}
}
Triangulation<2>::cell_iterator cell = triangulation.begin ();
- cell->face (0)->set_boundary_indicator (1);
- cell->face (1)->set_boundary_indicator (2);
+ cell->face (0)->set_boundary_id (1);
+ cell->face (1)->set_boundary_id (2);
for (unsigned int i = 2; i < 4; ++i)
- cell->face (i)->set_boundary_indicator (0);
+ cell->face (i)->set_boundary_id (0);
}
Triangulation<2>::face_iterator end = tria.end_face();
while (f != end)
{
- switch (f->boundary_indicator())
+ switch (f->boundary_id())
{
case 0:
- f->set_boundary_indicator(1);
+ f->set_boundary_id(1);
break;
case 1:
- f->set_boundary_indicator(2);
+ f->set_boundary_id(2);
break;
default:
- f->set_boundary_indicator(0);
+ f->set_boundary_id(0);
break;
}
++f;
{
for (unsigned int i=0; i<GeometryInfo<2>::faces_per_cell; ++i)
{
- if (cell->face(i)->boundary_indicator() == numbers::internal_face_boundary_id)
+ if (cell->face(i)->boundary_id() == numbers::internal_face_boundary_id)
continue;
// If x is zero, then this is part of the plane
if (cell->face(i)->center()(0) < p(0)+1.e-5)
- cell->face(i)->set_boundary_indicator(1);
+ cell->face(i)->set_boundary_id(1);
}
++cell;
}
Triangulation<2>::cell_iterator cell = tria.begin();
for (; cell!=tria.end(); ++cell)
{
- cell->face(2)->set_boundary_indicator(1);
+ cell->face(2)->set_boundary_id(1);
}
- tria.begin()->face(0)->set_boundary_indicator(3);
+ tria.begin()->face(0)->set_boundary_id(3);
- tria.last()->face(1)->set_boundary_indicator(2);
+ tria.last()->face(1)->set_boundary_id(2);
}
}
Triangulation<2>::cell_iterator cell = tria.begin();
for (; cell!=tria.end(); ++cell)
{
- cell->face(2)->set_boundary_indicator(1);
+ cell->face(2)->set_boundary_id(1);
}
- tria.begin()->face(0)->set_boundary_indicator(3);
+ tria.begin()->face(0)->set_boundary_id(3);
- tria.last()->face(1)->set_boundary_indicator(2);
+ tria.last()->face(1)->set_boundary_id(2);
}
}
{
Assert(false, ExcNotImplemented());
Triangulation<3>::cell_iterator cell = tria.begin();
- cell->face(1)->set_boundary_indicator(1);
+ cell->face(1)->set_boundary_id(1);
++cell;
- cell->face(3)->set_boundary_indicator(2);
+ cell->face(3)->set_boundary_id(2);
}
}
{
if (cell->vertex (0) (0) == -half_length)
{
- cell->face (4)->set_boundary_indicator (1);
+ cell->face (4)->set_boundary_id (1);
for (unsigned int i = 0; i < 4; ++i)
- cell->line (i)->set_boundary_indicator (0);
+ cell->line (i)->set_boundary_id (0);
}
if (cell->vertex (4) (0) == half_length)
{
- cell->face (5)->set_boundary_indicator (2);
+ cell->face (5)->set_boundary_id (2);
for (unsigned int i = 4; i < 8; ++i)
- cell->line (i)->set_boundary_indicator (0);
+ cell->line (i)->set_boundary_id (0);
}
for (unsigned int i = 0; i < 4; ++i)
- cell->face (i)->set_boundary_indicator (0);
+ cell->face (i)->set_boundary_id (0);
}
}
{
if (cell->face(i)->center()(0) > half_length-1.e-5)
{
- cell->face(i)->set_boundary_indicator(2);
+ cell->face(i)->set_boundary_id(2);
for (unsigned int e=0; e<GeometryInfo<3>::lines_per_face; ++e)
if ((std::fabs(cell->face(i)->line(e)->vertex(0)[1]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(0)[2]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(1)[1]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(1)[2]) == a))
- cell->face(i)->line(e)->set_boundary_indicator(2);
+ cell->face(i)->line(e)->set_boundary_id(2);
}
else if (cell->face(i)->center()(0) < -half_length+1.e-5)
{
- cell->face(i)->set_boundary_indicator(1);
+ cell->face(i)->set_boundary_id(1);
for (unsigned int e=0; e<GeometryInfo<3>::lines_per_face; ++e)
if ((std::fabs(cell->face(i)->line(e)->vertex(0)[1]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(0)[2]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(1)[1]) == a) ||
(std::fabs(cell->face(i)->line(e)->vertex(1)[2]) == a))
- cell->face(i)->line(e)->set_boundary_indicator(1);
+ cell->face(i)->line(e)->set_boundary_id(1);
}
}
}
// bounding faces unless both vertices are on the perimeter
if (cell->face(i)->center()(0) < center(0)+1.e-5*radius)
{
- cell->face(i)->set_boundary_indicator(1);
+ cell->face(i)->set_boundary_id(1);
for (unsigned int j=0; j<GeometryInfo<3>::lines_per_face; ++j)
{
const Point<3> line_vertices[2]
||
(std::fabs(line_vertices[1].distance(center)-radius) >
1e-5*radius))
- cell->face(i)->line(j)->set_boundary_indicator(1);
+ cell->face(i)->line(j)->set_boundary_id(1);
}
}
}
for (unsigned int f=0; f<4; ++f)
if (cell->at_boundary(f))
{
- quad.boundary_id = cell->face(f)->boundary_indicator();
+ quad.boundary_id = cell->face(f)->boundary_id();
bid = std::max(bid, quad.boundary_id);
for (unsigned int slice=0; slice<n_slices-1; ++slice)
{
if (colorize)
{
if (std::abs(dx + outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
else if (std::abs(dx - outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
else if (std::abs(dy + outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(2);
+ cell->face(f)->set_boundary_id(2);
else if (std::abs(dy - outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(3);
+ cell->face(f)->set_boundary_id(3);
else
- cell->face(f)->set_boundary_indicator(4);
+ cell->face(f)->set_boundary_id(4);
}
else
{
double d = (cell->face(f)->center() - center).norm();
if (d-inner_radius < 0)
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
else
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
}
}
}
if (colorize)
{
if (std::abs(dx + outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
else if (std::abs(dx - outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
else if (std::abs(dy + outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(2);
+ cell->face(f)->set_boundary_id(2);
else if (std::abs(dy - outer_radius) < eps)
- cell->face(f)->set_boundary_indicator(3);
+ cell->face(f)->set_boundary_id(3);
else if (std::abs(dz) < eps)
- cell->face(f)->set_boundary_indicator(4);
+ cell->face(f)->set_boundary_id(4);
else if (std::abs(dz - L) < eps)
- cell->face(f)->set_boundary_indicator(5);
+ cell->face(f)->set_boundary_id(5);
else
{
- cell->face(f)->set_boundary_indicator(6);
+ cell->face(f)->set_boundary_id(6);
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
- cell->face(f)->line(l)->set_boundary_indicator(6);
+ cell->face(f)->line(l)->set_boundary_id(6);
}
}
double d = c.norm();
if (d-inner_radius < 0)
{
- cell->face(f)->set_boundary_indicator(1);
+ cell->face(f)->set_boundary_id(1);
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_face; ++l)
- cell->face(f)->line(l)->set_boundary_indicator(1);
+ cell->face(f)->line(l)->set_boundary_id(1);
}
else
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
}
}
}
{
for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_face; ++i)
subcelldata.boundary_lines[f].vertices[i] = face->vertex_index(i);
- subcelldata.boundary_lines[f].boundary_id = face->boundary_indicator();
+ subcelldata.boundary_lines[f].boundary_id = face->boundary_id();
subcelldata.boundary_lines[f].manifold_id = face->manifold_id();
++f;
}
{
for (unsigned int i=0; i<GeometryInfo<dim>::vertices_per_face; ++i)
subcelldata.boundary_quads[f].vertices[i] = face->vertex_index(i);
- subcelldata.boundary_quads[f].boundary_id = face->boundary_indicator();
+ subcelldata.boundary_quads[f].boundary_id = face->boundary_id();
subcelldata.boundary_quads[f].manifold_id = face->manifold_id();
++f;
}
if ( face->at_boundary()
&&
(boundary_ids.empty() ||
- ( boundary_ids.find(face->boundary_indicator()) != boundary_ids.end())) )
+ ( boundary_ids.find(face->boundary_id()) != boundary_ids.end())) )
{
for (unsigned int j=0;
j<GeometryInfo<boundary_dim>::vertices_per_cell; ++j)
}
c_data.vertices[j] = map_vert_index[v_index];
- c_data.material_id = static_cast<types::material_id>(face->boundary_indicator());
+ c_data.material_id = static_cast<types::material_id>(face->boundary_id());
}
cells.push_back(c_data);
// Little trick to get -1
// for the interior
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
- out << ' ' << (int)(signed char)cell->face(f)->boundary_indicator();
+ out << ' ' << (int)(signed char)cell->face(f)->boundary_id();
out << '\n';
}
out << "attribute \"dep\" string \"connections\"" << '\n' << '\n';
{
Triangulation<dim, spacedim>::face_iterator
face = cell->face(face_reorder[f]);
- const types::boundary_id bi = face->boundary_indicator();
+ const types::boundary_id bi = face->boundary_id();
if (bi != numbers::internal_face_boundary_id)
{
// Code for polyline
for (face=tria.begin_active_face(), endf=tria.end_face();
face != endf; ++face)
if ((face->at_boundary()) &&
- (face->boundary_indicator() != 0))
+ (face->boundary_id() != 0))
n_faces++;
return n_faces;
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
if (cell->line(l)->at_boundary()
&&
- (cell->line(l)->boundary_indicator() != 0)
+ (cell->line(l)->boundary_id() != 0)
&&
(cell->line(l)->user_flag_set() == false))
{
for (face=tria.begin_active_face(), endf=tria.end_face();
face != endf; ++face)
if (face->at_boundary() &&
- (face->boundary_indicator() != 0))
+ (face->boundary_id() != 0))
{
out << index << ' ';
switch (dim)
default:
Assert (false, ExcNotImplemented());
}
- out << static_cast<unsigned int>(face->boundary_indicator())
+ out << static_cast<unsigned int>(face->boundary_id())
<< ' '
- << static_cast<unsigned int>(face->boundary_indicator())
+ << static_cast<unsigned int>(face->boundary_id())
<< ' ' << GeometryInfo<dim>::vertices_per_face;
// note: vertex numbers are 1-base
for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_face; ++vertex)
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
if (cell->line(l)->at_boundary()
&&
- (cell->line(l)->boundary_indicator() != 0)
+ (cell->line(l)->boundary_id() != 0)
&&
(cell->line(l)->user_flag_set() == false))
{
out << index << " 1 ";
- out << static_cast<unsigned int>(cell->line(l)->boundary_indicator())
+ out << static_cast<unsigned int>(cell->line(l)->boundary_id())
<< ' '
- << static_cast<unsigned int>(cell->line(l)->boundary_indicator())
+ << static_cast<unsigned int>(cell->line(l)->boundary_id())
<< " 2 ";
// note: vertex numbers are 1-base
for (unsigned int vertex=0; vertex<2; ++vertex)
for (face=tria.begin_active_face(), endf=tria.end_face();
face != endf; ++face)
if (face->at_boundary() &&
- (face->boundary_indicator() != 0))
+ (face->boundary_id() != 0))
{
out << index << " "
- << static_cast<unsigned int>(face->boundary_indicator())
+ << static_cast<unsigned int>(face->boundary_id())
<< " ";
switch (dim)
{
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
if (cell->line(l)->at_boundary()
&&
- (cell->line(l)->boundary_indicator() != 0)
+ (cell->line(l)->boundary_id() != 0)
&&
(cell->line(l)->user_flag_set() == false))
{
out << index << " "
- << static_cast<unsigned int>(cell->line(l)->boundary_indicator())
+ << static_cast<unsigned int>(cell->line(l)->boundary_id())
<< " line ";
// note: vertex numbers in ucd format are 1-base
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int i = 0; i < GeometryInfo<dim>::faces_per_cell; ++i)
{
const typename CONTAINER::face_iterator face = cell->face(i);
- if (face->at_boundary() && face->boundary_indicator() == b_id1)
+ if (face->at_boundary() && face->boundary_id() == b_id1)
{
const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
= std::make_pair(cell, i);
pairs1.insert(pair1);
}
- if (face->at_boundary() && face->boundary_indicator() == b_id2)
+ if (face->at_boundary() && face->boundary_id() == b_id2)
{
const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
= std::make_pair(cell, i);
const typename CONTAINER::face_iterator face_1 = cell->face(2*direction);
const typename CONTAINER::face_iterator face_2 = cell->face(2*direction+1);
- if (face_1->at_boundary() && face_1->boundary_indicator() == b_id)
+ if (face_1->at_boundary() && face_1->boundary_id() == b_id)
{
const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
= std::make_pair(cell, 2*direction);
pairs1.insert(pair1);
}
- if (face_2->at_boundary() && face_2->boundary_indicator() == b_id)
+ if (face_2->at_boundary() && face_2->boundary_id() == b_id)
{
const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
= std::make_pair(cell, 2*direction+1);
if (cell->face(f)->at_boundary())
{
cell->face(f)->set_manifold_id
- (static_cast<types::manifold_id>(cell->face(f)->boundary_indicator()));
+ (static_cast<types::manifold_id>(cell->face(f)->boundary_id()));
if (reset_boundary_ids == true)
- cell->face(f)->set_boundary_indicator(0);
+ cell->face(f)->set_boundary_id(0);
}
}
template <>
- types::global_dof_index DoFHandler<1>::n_boundary_dofs (const FunctionMap &boundary_indicators) const
+ types::global_dof_index DoFHandler<1>::n_boundary_dofs (const FunctionMap &boundary_ids) const
{
Assert (finite_elements != 0, ExcNoFESelected());
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (FunctionMap::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (FunctionMap::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((i->first == 0) || (i->first == 1),
ExcInvalidBoundaryIndicator());
types::global_dof_index n = 0;
// search left-most cell
- if (boundary_indicators.find (0) != boundary_indicators.end())
+ if (boundary_ids.find (0) != boundary_ids.end())
{
cell = this->begin_active();
while (!cell->at_boundary(0))
}
// same with right-most cell
- if (boundary_indicators.find (1) != boundary_indicators.end())
+ if (boundary_ids.find (1) != boundary_ids.end())
{
cell = this->begin_active();
while (!cell->at_boundary(1))
template <>
- types::global_dof_index DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
+ types::global_dof_index DoFHandler<1>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
Assert (finite_elements != 0, ExcNoFESelected());
// check that only boundary
// indicators 0 and 1 are allowed
// in 1d
- for (std::set<types::boundary_id>::const_iterator i=boundary_indicators.begin();
- i!=boundary_indicators.end(); ++i)
+ for (std::set<types::boundary_id>::const_iterator i=boundary_ids.begin();
+ i!=boundary_ids.end(); ++i)
Assert ((*i == 0) || (*i == 1),
ExcInvalidBoundaryIndicator());
types::global_dof_index n = 0;
// search left-most cell
- if (boundary_indicators.find (0) != boundary_indicators.end())
+ if (boundary_ids.find (0) != boundary_ids.end())
{
cell = this->begin_active();
while (!cell->at_boundary(0))
}
// same with right-most cell
- if (boundary_indicators.find (1) != boundary_indicators.end())
+ if (boundary_ids.find (1) != boundary_ids.end())
{
cell = this->begin_active();
while (!cell->at_boundary(1))
template<int dim, int spacedim>
types::global_dof_index
- DoFHandler<dim,spacedim>::n_boundary_dofs (const FunctionMap &boundary_indicators) const
+ DoFHandler<dim,spacedim>::n_boundary_dofs (const FunctionMap &boundary_ids) const
{
Assert (finite_elements != 0, ExcNoFESelected());
- Assert (boundary_indicators.find(numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find(numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
// same as above, but with
for (; cell!=endc; ++cell)
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->at_boundary(f) &&
- (boundary_indicators.find(cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end()))
+ (boundary_ids.find(cell->face(f)->boundary_id()) !=
+ boundary_ids.end()))
{
const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
dofs_on_face.resize (dofs_per_face);
template<int dim, int spacedim>
types::global_dof_index
- DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const
+ DoFHandler<dim,spacedim>::n_boundary_dofs (const std::set<types::boundary_id> &boundary_ids) const
{
Assert (finite_elements != 0, ExcNoFESelected());
- Assert (boundary_indicators.find (numbers::internal_face_boundary_id) == boundary_indicators.end(),
+ Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
ExcInvalidBoundaryIndicator());
// same as above, but with
for (; cell!=endc; ++cell)
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->at_boundary(f) &&
- (boundary_indicators.find(cell->face(f)->boundary_indicator()) !=
- boundary_indicators.end()))
+ (boundary_ids.find(cell->face(f)->boundary_id()) !=
+ boundary_ids.end()))
{
const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
dofs_on_face.resize (dofs_per_face);
{
const typename DoFHandler<dim,spacedim>::face_iterator
face = cell->face(face_no);
- const types::boundary_id bi = face->boundary_indicator();
+ const types::boundary_id bi = face->boundary_id();
// Face is listed in
// boundary map
if (function_map.find(bi) != function_map.end())
}
typename DoFHandler<dim,spacedim>::face_iterator face = cell->face(face_no);
- const types::boundary_id boundary_component = face->boundary_indicator();
+ const types::boundary_id boundary_component = face->boundary_id();
if (function_map.find(boundary_component) != function_map.end())
// face is of the right component
{
// neumann boundary face. compute difference between normal derivative
// and boundary function
{
- const types::boundary_id boundary_indicator = face->boundary_indicator();
+ const types::boundary_id boundary_id = face->boundary_id();
- Assert (parallel_data.neumann_bc->find(boundary_indicator) !=
+ Assert (parallel_data.neumann_bc->find(boundary_id) !=
parallel_data.neumann_bc->end(),
ExcInternalError ());
// get the values of the boundary function at the quadrature points
if (n_components == 1)
{
std::vector<double> g(n_q_points);
- parallel_data.neumann_bc->find(boundary_indicator)->second
+ parallel_data.neumann_bc->find(boundary_id)->second
->value_list (fe_face_values_cell.get_present_fe_values()
.get_quadrature_points(), g);
{
std::vector<dealii::Vector<double> >
g(n_q_points, dealii::Vector<double>(n_components));
- parallel_data.neumann_bc->find(boundary_indicator)->second
+ parallel_data.neumann_bc->find(boundary_id)->second
->vector_value_list (fe_face_values_cell.get_present_fe_values()
.get_quadrature_points(),
g);
// face into the list of faces with contribution zero.
if (face->at_boundary()
&&
- (parallel_data.neumann_bc->find(face->boundary_indicator()) ==
+ (parallel_data.neumann_bc->find(face->boundary_id()) ==
parallel_data.neumann_bc->end()))
{
local_face_integrals[face]
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
// check if this face is on that part of
// the boundary we are interested in
- if (boundary_functions.find(cell->face(face)->boundary_indicator()) !=
+ if (boundary_functions.find(cell->face(face)->boundary_id()) !=
boundary_functions.end())
{
copy_data.cell_matrix.push_back(FullMatrix<double> (copy_data.dofs_per_cell,
if (fe_is_system)
// FE has several components
{
- boundary_functions.find(cell->face(face)->boundary_indicator())
+ boundary_functions.find(cell->face(face)->boundary_id())
->second->vector_value_list (fe_values.get_quadrature_points(),
rhs_values_system);
else
// FE is a scalar one
{
- boundary_functions.find(cell->face(face)->boundary_indicator())
+ boundary_functions.find(cell->face(face)->boundary_id())
->second->value_list (fe_values.get_quadrature_points(), rhs_values_scalar);
if (coefficient != 0)
{
// check if this face is on that part of
// the boundary we are interested in
- if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
+ if (boundary_functions.find(copy_data.cell->face(face)->boundary_id()) !=
boundary_functions.end())
{
for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
// check if this face is on that part of
// the boundary we are interested in
- if (boundary_functions.find(cell->face(face)->boundary_indicator()) !=
+ if (boundary_functions.find(cell->face(face)->boundary_id()) !=
boundary_functions.end())
{
x_fe_values.reinit (cell, face);
{
rhs_values_system.resize (fe_values.n_quadrature_points,
Vector<double>(n_function_components));
- boundary_functions.find(cell->face(face)->boundary_indicator())
+ boundary_functions.find(cell->face(face)->boundary_id())
->second->vector_value_list (fe_values.get_quadrature_points(),
rhs_values_system);
// FE is a scalar one
{
rhs_values_scalar.resize (fe_values.n_quadrature_points);
- boundary_functions.find(cell->face(face)->boundary_indicator())
+ boundary_functions.find(cell->face(face)->boundary_id())
->second->value_list (fe_values.get_quadrature_points(), rhs_values_scalar);
if (coefficient != 0)
{
// check if this face is on that part of
// the boundary we are interested in
- if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
+ if (boundary_functions.find(copy_data.cell->face(face)->boundary_id()) !=
boundary_functions.end())
{
#ifdef DEBUG
projects / dealii.git / commitdiff