--- /dev/null
+Deprecated: The static member variables DoFHandler::invalid_dof_index
+and hp::DoFHandler::invalid_dof_index are now deprecated. Use
+numbers::invalid_dof_index instead.
+<br>
+(Wolfgang Bangerth, 2017/06/20)
*
* Please note that you should not rely on it having a certain value, but
* rather take its symbolic name.
+ *
+ * @deprecated Use numbers::invalid_dof_index instead.
*/
- static const types::global_dof_index invalid_dof_index = numbers::invalid_dof_index;
+ static const types::global_dof_index invalid_dof_index DEAL_II_DEPRECATED = numbers::invalid_dof_index;
/**
* The default index of the finite element to be used on a given cell. Since
* freedom. The map_dof_to_boundary_indices() function does exactly this: it
* provides a vector with as many entries as there are degrees of freedom on
* the whole domain, with each entry being the number in the numbering of the
- * boundary or DoFHandler::invalid_dof_index if the dof is not on the
+ * boundary or numbers::invalid_dof_index if the dof is not on the
* boundary.
*
* With this vector, one can get, for any given degree of freedom, a unique
* number among those DoFs that sit on the boundary; or, if your DoF was
- * interior to the domain, the result would be DoFHandler::invalid_dof_index.
+ * interior to the domain, the result would be numbers::invalid_dof_index.
* We need this mapping, for example, to build the mass matrix on the boundary
* (for this, see make_boundary_sparsity_pattern() function, the corresponding
* section below, as well as the MatrixCreator namespace documentation).
* intermixed.
*
* Degrees of freedom on the boundary but not on one of the specified boundary
- * parts are given the index DoFHandler::invalid_dof_index, as if they were in
+ * parts are given the index numbers::invalid_dof_index, as if they were in
* the interior. If no boundary indicator was given or if no face of a cell
* has a boundary indicator contained in the given list, the vector of new
- * indices consists solely of DoFHandler::invalid_dof_index.
+ * indices consists solely of numbers::invalid_dof_index.
*
* (As a side note, for corner cases: The question what a degree of freedom on
* the boundary is, is not so easy. It should really be a degree of freedom
* <tt>mapping[dof]</tt> gives the index of the degree of freedom with
* global number @p dof in the list of degrees of freedom on the boundary.
* If the degree of freedom requested is not on the boundary, the value of
- * <tt>mapping[dof]</tt> is @p invalid_dof_index. This function is mainly
+ * <tt>mapping[dof]</tt> is numbers::invalid_dof_index. This function is mainly
* used when setting up matrices and vectors on the boundary from the trial
* functions, which have global numbers, while the matrices and vectors use
* numbers of the trial functions local to the boundary.
*
* Please note that you should not rely on it having a certain value, but
* rather take its symbolic name.
+ *
+ * @deprecated Use numbers::invalid_dof_index instead.
*/
- static const types::global_dof_index invalid_dof_index = numbers::invalid_dof_index;
+ static const types::global_dof_index invalid_dof_index DEAL_II_DEPRECATED = numbers::invalid_dof_index;
/**
* The default index of the finite element to be used on a given cell. For
types::global_dof_index max_element = static_cast<types::global_dof_index>(0);
for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
i!=dof_to_boundary_mapping.end(); ++i)
- if ((*i != hp::DoFHandler<dim,spacedim>::invalid_dof_index) &&
+ if ((*i != numbers::invalid_dof_index) &&
(*i > max_element))
max_element = *i;
Assert (max_element == matrix.n()-1, ExcInternalError());
}
// fill in boundary values
for (unsigned int i=0; i<dof_to_boundary_mapping.size(); ++i)
- if (dof_to_boundary_mapping[i] != DoFHandler<dim,spacedim>::invalid_dof_index
+ if (dof_to_boundary_mapping[i] != numbers::invalid_dof_index
&& ! excluded_dofs[dof_to_boundary_mapping[i]])
{
AssertIsFinite(boundary_projection(dof_to_boundary_mapping[i]));
template <int dim, int spacedim>
const types::global_dof_index *dummy ()
{
- return &dealii::DoFHandler<dim,spacedim>::invalid_dof_index;
+ return &dealii::numbers::invalid_dof_index;
}
}
dof_handler.vertex_dofs
.resize(dof_handler.tria->n_vertices() *
dof_handler.selected_fe->dofs_per_vertex,
- DoFHandler<1,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_line,
- DoFHandler<1,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels.back()->cell_dof_indices_cache
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_cell,
- DoFHandler<1,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
}
dof_handler.vertex_dofs
.resize(dof_handler.tria->n_vertices() *
dof_handler.selected_fe->dofs_per_vertex,
- DoFHandler<2,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_quad,
- DoFHandler<2,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels.back()->cell_dof_indices_cache
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_cell,
- DoFHandler<2,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
dof_handler.faces.reset (new internal::DoFHandler::DoFFaces<2>);
dof_handler.faces->lines.dofs
.resize (dof_handler.tria->n_raw_lines() *
dof_handler.selected_fe->dofs_per_line,
- DoFHandler<2,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
}
dof_handler.vertex_dofs
.resize(dof_handler.tria->n_vertices() *
dof_handler.selected_fe->dofs_per_vertex,
- DoFHandler<3,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_hex,
- DoFHandler<3,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels.back()->cell_dof_indices_cache
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.selected_fe->dofs_per_cell,
- DoFHandler<3,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
dof_handler.faces.reset (new internal::DoFHandler::DoFFaces<3>);
dof_handler.faces->lines.dofs
.resize (dof_handler.tria->n_raw_lines() *
dof_handler.selected_fe->dofs_per_line,
- DoFHandler<3,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.faces->quads.dofs
.resize (dof_handler.tria->n_raw_quads() *
dof_handler.selected_fe->dofs_per_quad,
- DoFHandler<3,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
}
for (unsigned int i = 0; i < n_levels; ++i)
{
dof_handler.mg_levels.emplace_back (new internal::DoFHandler::DoFLevel<1>);
- dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines (i) * dofs_per_line, DoFHandler<1>::invalid_dof_index);
+ dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines (i) * dofs_per_line, numbers::invalid_dof_index);
}
const unsigned int &n_vertices = tria.n_vertices ();
for (unsigned int i = 0; i < n_levels; ++i)
{
dof_handler.mg_levels.emplace_back (new internal::DoFHandler::DoFLevel<2>);
- dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads (i) * fe.dofs_per_quad, DoFHandler<2>::invalid_dof_index);
+ dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads (i) * fe.dofs_per_quad, numbers::invalid_dof_index);
}
dof_handler.mg_faces.reset (new internal::DoFHandler::DoFFaces<2>);
- dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, DoFHandler<2>::invalid_dof_index);
+ dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, numbers::invalid_dof_index);
const unsigned int &n_vertices = tria.n_vertices ();
for (unsigned int i = 0; i < n_levels; ++i)
{
dof_handler.mg_levels.emplace_back (new internal::DoFHandler::DoFLevel<3>);
- dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_hexs (i) * fe.dofs_per_hex, DoFHandler<3>::invalid_dof_index);
+ dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_hexs (i) * fe.dofs_per_hex, numbers::invalid_dof_index);
}
dof_handler.mg_faces.reset (new internal::DoFHandler::DoFFaces<3>);
- dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, DoFHandler<3>::invalid_dof_index);
- dof_handler.mg_faces->quads.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads () * fe.dofs_per_quad, DoFHandler<3>::invalid_dof_index);
+ dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, numbers::invalid_dof_index);
+ dof_handler.mg_faces->quads.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads () * fe.dofs_per_quad, numbers::invalid_dof_index);
const unsigned int &n_vertices = tria.n_vertices ();
for (std::vector<types::global_dof_index>::iterator i=mg_levels[level]->dof_object.dofs.begin();
i!=mg_levels[level]->dof_object.dofs.end(); ++i)
{
- if (*i != DoFHandler<1>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = new_numbers[*i];
for (std::vector<types::global_dof_index>::iterator i=mg_levels[level]->dof_object.dofs.begin();
i!=mg_levels[level]->dof_object.dofs.end(); ++i)
{
- if (*i != DoFHandler<2>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = new_numbers[*i];
for (std::vector<types::global_dof_index>::iterator i=mg_levels[level]->dof_object.dofs.begin();
i!=mg_levels[level]->dof_object.dofs.end(); ++i)
{
- if (*i != DoFHandler<3>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = new_numbers[*i];
const unsigned int n_indices = n_levels * dofs_per_vertex;
indices = new types::global_dof_index[n_indices];
- std::fill (indices, indices+n_indices, DoFHandler<dim,spacedim>::invalid_dof_index);
+ std::fill (indices, indices+n_indices, numbers::invalid_dof_index);
indices_offset = new types::global_dof_index[n_levels];
for (unsigned int i = 0; i < n_levels; ++i)
if (dof_handler.get_fe().dofs_per_vertex > 0)
for (unsigned int v=0; v<GeometryInfo<1>::vertices_per_cell; ++v)
{
- if (cell->vertex_dof_index (v,0) == DoFHandler<1,spacedim>::invalid_dof_index)
+ if (cell->vertex_dof_index (v,0) == numbers::invalid_dof_index)
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_vertex; ++d)
{
Assert ((cell->vertex_dof_index (v,d) ==
- DoFHandler<1,spacedim>::invalid_dof_index),
+ numbers::invalid_dof_index),
ExcInternalError());
cell->set_vertex_dof_index (v, d, next_free_dof++);
}
else
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_vertex; ++d)
Assert ((cell->vertex_dof_index (v,d) !=
- DoFHandler<1,spacedim>::invalid_dof_index),
+ numbers::invalid_dof_index),
ExcInternalError());
}
for (unsigned int vertex=0; vertex<GeometryInfo<2>::vertices_per_cell; ++vertex)
// check whether dofs for this vertex have been distributed
// (checking the first dof should be good enough)
- if (cell->vertex_dof_index(vertex, 0) == DoFHandler<2,spacedim>::invalid_dof_index)
+ if (cell->vertex_dof_index(vertex, 0) == numbers::invalid_dof_index)
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_vertex; ++d)
cell->set_vertex_dof_index (vertex, d, next_free_dof++);
// distribute dofs if necessary: check whether line dof is already
// numbered (checking the first dof should be good enough)
- if (line->dof_index(0) == DoFHandler<2,spacedim>::invalid_dof_index)
+ if (line->dof_index(0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_line; ++d)
line->set_dof_index (d, next_free_dof++);
for (unsigned int vertex=0; vertex<GeometryInfo<3>::vertices_per_cell; ++vertex)
// check whether dofs for this vertex have been distributed
// (checking the first dof should be good enough)
- if (cell->vertex_dof_index(vertex, 0) == DoFHandler<3,spacedim>::invalid_dof_index)
+ if (cell->vertex_dof_index(vertex, 0) == numbers::invalid_dof_index)
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_vertex; ++d)
cell->set_vertex_dof_index (vertex, d, next_free_dof++);
// distribute dofs if necessary: check whether line dof is already
// numbered (checking the first dof should be good enough)
- if (line->dof_index(0) == DoFHandler<3,spacedim>::invalid_dof_index)
+ if (line->dof_index(0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_line; ++d)
line->set_dof_index (d, next_free_dof++);
// distribute dofs if necessary: check whether line dof is already
// numbered (checking the first dof should be good enough)
- if (quad->dof_index(0) == DoFHandler<3,spacedim>::invalid_dof_index)
+ if (quad->dof_index(0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<dof_handler.get_fe().dofs_per_quad; ++d)
quad->set_dof_index (d, next_free_dof++);
// check whether dofs for this
// vertex have been distributed
// (only check the first dof)
- if (cell->mg_vertex_dof_index(cell->level(), vertex, 0) == DoFHandler<2>::invalid_dof_index)
+ if (cell->mg_vertex_dof_index(cell->level(), vertex, 0) == numbers::invalid_dof_index)
for (unsigned int d=0; d<cell->get_fe().dofs_per_vertex; ++d)
cell->set_mg_vertex_dof_index (cell->level(), vertex, d, next_free_dof++);
// distribute dofs if necessary:
// check whether line dof is already
// numbered (check only first dof)
- if (line->mg_dof_index(cell->level(), 0) == DoFHandler<2>::invalid_dof_index)
+ if (line->mg_dof_index(cell->level(), 0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<cell->get_fe().dofs_per_line; ++d)
line->set_mg_dof_index (cell->level(), d, next_free_dof++);
// check whether dofs for this
// vertex have been distributed
// (only check the first dof)
- if (cell->mg_vertex_dof_index(cell->level(), vertex, 0) == DoFHandler<3>::invalid_dof_index)
+ if (cell->mg_vertex_dof_index(cell->level(), vertex, 0) == numbers::invalid_dof_index)
for (unsigned int d=0; d<cell->get_fe().dofs_per_vertex; ++d)
cell->set_mg_vertex_dof_index (cell->level(), vertex, d, next_free_dof++);
// distribute dofs if necessary:
// check whether line dof is already
// numbered (check only first dof)
- if (line->mg_dof_index(cell->level(), 0) == DoFHandler<3>::invalid_dof_index)
+ if (line->mg_dof_index(cell->level(), 0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<cell->get_fe().dofs_per_line; ++d)
line->set_mg_dof_index (cell->level(), d, next_free_dof++);
// distribute dofs if necessary:
// check whether line dof is already
// numbered (check only first dof)
- if (quad->mg_dof_index(cell->level(), 0) == DoFHandler<3>::invalid_dof_index)
+ if (quad->mg_dof_index(cell->level(), 0) == numbers::invalid_dof_index)
// if not: distribute dofs
for (unsigned int d=0; d<cell->get_fe().dofs_per_quad; ++d)
quad->set_mg_dof_index (cell->level(), d, next_free_dof++);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.vertex_dofs.begin();
i!=dof_handler.vertex_dofs.end(); ++i)
- if (*i != DoFHandler<1,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = new_numbers[*i];
else if (check_validity)
// if index is invalid_dof_index: check if this one
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.levels[level]->dof_object.dofs.begin();
i!=dof_handler.levels[level]->dof_object.dofs.end(); ++i)
- if (*i != DoFHandler<1,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = new_numbers[*i];
// update the cache used for cell dof indices
{
const dealii::types::global_dof_index idx = i->get_index (level, d);
if (check_validity)
- Assert(idx != DoFHandler<1>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<1>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
i->set_index (level, d,
(indices.n_elements() == 0)?
(new_numbers[idx]) :
i!=dof_handler.mg_levels[level]->dof_object.dofs.end();
++i)
{
- if (*i != DoFHandler<1>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = (indices.n_elements() == 0)?
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.vertex_dofs.begin();
i!=dof_handler.vertex_dofs.end(); ++i)
- if (*i != DoFHandler<2,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = (indices.n_elements() == 0)?
(new_numbers[*i]) :
(new_numbers[indices.index_within_set(*i)]);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.faces->lines.dofs.begin();
i!=dof_handler.faces->lines.dofs.end(); ++i)
- if (*i != DoFHandler<2,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.levels[level]->dof_object.dofs.begin();
i!=dof_handler.levels[level]->dof_object.dofs.end(); ++i)
- if (*i != DoFHandler<2,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
{
const dealii::types::global_dof_index idx = i->get_index (level, d);
if (check_validity)
- Assert(idx != DoFHandler<2>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<1>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
i->set_index (level, d/*, dof_handler.get_fe().dofs_per_vertex*/,
((indices.n_elements() == 0) ?
new_numbers[idx] :
{
const dealii::types::global_dof_index idx = cell->line(l)->mg_dof_index(level, d);
if (check_validity)
- Assert(idx != DoFHandler<2>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<1>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
cell->line(l)->set_mg_dof_index (level, d, ((indices.n_elements() == 0) ?
new_numbers[idx] :
new_numbers[indices.index_within_set(idx)]));
for (std::vector<types::global_dof_index>::iterator i=dof_handler.mg_levels[level]->dof_object.dofs.begin();
i!=dof_handler.mg_levels[level]->dof_object.dofs.end(); ++i)
{
- if (*i != DoFHandler<2>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = ((indices.n_elements() == 0) ?
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.vertex_dofs.begin();
i!=dof_handler.vertex_dofs.end(); ++i)
- if (*i != DoFHandler<3,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.faces->lines.dofs.begin();
i!=dof_handler.faces->lines.dofs.end(); ++i)
- if (*i != DoFHandler<3,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.faces->quads.dofs.begin();
i!=dof_handler.faces->quads.dofs.end(); ++i)
- if (*i != DoFHandler<3,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
for (std::vector<types::global_dof_index>::iterator
i=dof_handler.levels[level]->dof_object.dofs.begin();
i!=dof_handler.levels[level]->dof_object.dofs.end(); ++i)
- if (*i != DoFHandler<3,spacedim>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
*i = ((indices.n_elements() == 0) ?
new_numbers[*i] :
new_numbers[indices.index_within_set(*i)]);
{
const dealii::types::global_dof_index idx = i->get_index (level, d);
if (check_validity)
- Assert(idx != DoFHandler<3>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<3>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
i->set_index (level, d,
((indices.n_elements() == 0) ?
new_numbers[idx] :
{
const dealii::types::global_dof_index idx = cell->line(l)->mg_dof_index(level, d);
if (check_validity)
- Assert(idx != DoFHandler<3>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<3>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
cell->line(l)->set_mg_dof_index (level, d, ((indices.n_elements() == 0) ?
new_numbers[idx] :
new_numbers[indices.index_within_set(idx)]));
{
const dealii::types::global_dof_index idx = cell->quad(l)->mg_dof_index(level, d);
if (check_validity)
- Assert(idx != DoFHandler<3>::invalid_dof_index, ExcInternalError ());
+ Assert(idx != numbers::invalid_dof_index, ExcInternalError ());
- if (idx != DoFHandler<1>::invalid_dof_index)
+ if (idx != numbers::invalid_dof_index)
cell->quad(l)->set_mg_dof_index (level, d, ((indices.n_elements() == 0) ?
new_numbers[idx] :
new_numbers[indices.index_within_set(idx)]));
for (std::vector<types::global_dof_index>::iterator i=dof_handler.mg_levels[level]->dof_object.dofs.begin();
i!=dof_handler.mg_levels[level]->dof_object.dofs.end(); ++i)
{
- if (*i != DoFHandler<3>::invalid_dof_index)
+ if (*i != numbers::invalid_dof_index)
{
Assert(*i<new_numbers.size(), ExcInternalError());
*i = ((indices.n_elements() == 0) ?
bool complete = true;
for (unsigned int i=0; i<dof_indices.size(); ++i)
- if (dofs[i] != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (dofs[i] != numbers::invalid_dof_index)
{
Assert((dof_indices[i] ==
- (DoFHandler<dim,spacedim>::invalid_dof_index))
+ (numbers::invalid_dof_index))
||
(dof_indices[i]==dofs[i]),
ExcInternalError());
bool complete = true;
for (unsigned int i=0; i<dof_indices.size(); ++i)
- if (dofs[i] != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (dofs[i] != numbers::invalid_dof_index)
{
Assert((dof_indices[i] ==
- (DoFHandler<dim,spacedim>::invalid_dof_index))
+ (numbers::invalid_dof_index))
||
(dof_indices[i]==dofs[i]),
ExcInternalError());
if (local_dof_indices.end() !=
std::find (local_dof_indices.begin(),
local_dof_indices.end(),
- DoFHandler<dim,spacedim>::invalid_dof_index))
+ numbers::invalid_dof_index))
cell->set_user_flag();
else
cell->clear_user_flag();
local_dof_indices.resize (cell->get_fe().dofs_per_cell);
cell->get_dof_indices (local_dof_indices);
for (unsigned int i=0; i<cell->get_fe().dofs_per_cell; ++i)
- if (local_dof_indices[i] != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (local_dof_indices[i] != numbers::invalid_dof_index)
renumbering[local_dof_indices[i]]
- = DoFHandler<dim,spacedim>::invalid_dof_index;
+ = numbers::invalid_dof_index;
}
}
number_cache.n_locally_owned_dofs = 0;
for (std::vector<dealii::types::global_dof_index>::iterator it=renumbering.begin();
it!=renumbering.end(); ++it)
- if (*it != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (*it != numbers::invalid_dof_index)
*it = number_cache.n_locally_owned_dofs++;
//* 3. communicate local dofcount and shift ids to make them
static_cast<dealii::types::global_dof_index>(0));
for (std::vector<dealii::types::global_dof_index>::iterator it=renumbering.begin();
it!=renumbering.end(); ++it)
- if (*it != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (*it != numbers::invalid_dof_index)
(*it) += shift;
// now re-enumerate all dofs to this shifted and condensed
if (local_dof_indices.end() !=
std::find (local_dof_indices.begin(),
local_dof_indices.end(),
- DoFHandler<dim,spacedim>::invalid_dof_index))
+ numbers::invalid_dof_index))
{
if (cell->is_ghost())
{
local_dof_indices.resize (cell->get_fe().dofs_per_cell);
cell->get_mg_dof_indices (local_dof_indices);
for (unsigned int i=0; i<cell->get_fe().dofs_per_cell; ++i)
- if (local_dof_indices[i] != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (local_dof_indices[i] != numbers::invalid_dof_index)
renumbering[local_dof_indices[i]]
- = DoFHandler<dim,spacedim>::invalid_dof_index;
+ = numbers::invalid_dof_index;
}
}
level_number_cache.n_locally_owned_dofs = 0;
for (std::vector<dealii::types::global_dof_index>::iterator it=renumbering.begin();
it!=renumbering.end(); ++it)
- if (*it != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (*it != numbers::invalid_dof_index)
*it = level_number_cache.n_locally_owned_dofs++;
//* 3. communicate local dofcount and shift ids to make
static_cast<dealii::types::global_dof_index>(0));
for (std::vector<dealii::types::global_dof_index>::iterator it=renumbering.begin();
it!=renumbering.end(); ++it)
- if (*it != DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (*it != numbers::invalid_dof_index)
(*it) += shift;
// now re-enumerate all dofs to this shifted and condensed
if (local_dof_indices.end() !=
std::find (local_dof_indices.begin(),
local_dof_indices.end(),
- DoFHandler<dim,spacedim>::invalid_dof_index))
+ numbers::invalid_dof_index))
{
Assert(false, ExcMessage ("not all DoFs got distributed!"));
}
cell->get_dof_indices (local_dof_indices);
for (unsigned int i=0; i<cell->get_fe().dofs_per_cell; ++i)
{
- if (local_dof_indices[i] == DoFHandler<dim,spacedim>::invalid_dof_index)
+ if (local_dof_indices[i] == numbers::invalid_dof_index)
continue;
if (!dof_handler.locally_owned_dofs().is_element(local_dof_indices[i]))
{
//this DoF is not owned by us, so set it to invalid.
local_dof_indices[i]
- = DoFHandler<dim,spacedim>::invalid_dof_index;
+ = numbers::invalid_dof_index;
}
}
const bool use_constraints)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_Cuthill_McKee(renumbering, dof_handler, reversed_numbering,
use_constraints);
new_dof_indices[index_map[inv_perm[c]]] = c;
Assert (std::find (new_dof_indices.begin(), new_dof_indices.end(),
- DoFHandlerType::invalid_dof_index) == new_dof_indices.end(),
+ numbers::invalid_dof_index) == new_dof_indices.end(),
ExcInternalError());
}
const bool use_constraints)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_king_ordering(renumbering, dof_handler, reversed_numbering,
use_constraints);
new_dof_indices[index_map[inv_perm[c]]] = c;
Assert (std::find (new_dof_indices.begin(), new_dof_indices.end(),
- DoFHandlerType::invalid_dof_index) == new_dof_indices.end(),
+ numbers::invalid_dof_index) == new_dof_indices.end(),
ExcInternalError());
}
const bool use_constraints)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_minimum_degree(renumbering, dof_handler, reversed_numbering,
use_constraints);
const std::vector<types::global_dof_index> &starting_indices)
{
std::vector<types::global_dof_index> renumbering(dof_handler.locally_owned_dofs().n_elements(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_Cuthill_McKee(renumbering, dof_handler, reversed_numbering,
use_constraints, starting_indices);
const std::vector<unsigned int> &component_order_arg)
{
std::vector<types::global_dof_index> renumbering (dof_handler.n_locally_owned_dofs(),
- DoFHandler<dim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename DoFHandler<dim,spacedim>::active_cell_iterator
start = dof_handler.begin_active();
{
//TODO: Merge with previous function
std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(),
- hp::DoFHandler<dim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename hp::DoFHandler<dim>::active_cell_iterator
start = dof_handler.begin_active();
ExcNotInitialized());
std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(level),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
typename DoFHandlerType::level_cell_iterator start =dof_handler.begin(level);
typename DoFHandlerType::level_cell_iterator end = dof_handler.end(level);
block_wise (DoFHandler<dim,spacedim> &dof_handler)
{
std::vector<types::global_dof_index> renumbering (dof_handler.n_locally_owned_dofs(),
- DoFHandler<dim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename DoFHandler<dim,spacedim>::active_cell_iterator
start = dof_handler.begin_active();
block_wise (hp::DoFHandler<dim,spacedim> &dof_handler)
{
std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(),
- hp::DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
start = dof_handler.begin_active();
ExcNotInitialized());
std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(level),
- DoFHandler<dim, spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename DoFHandler<dim, spacedim>::level_cell_iterator
start =dof_handler.begin(level);
{
// this is a locally owned DoF, assign new number if not assigned a number yet
unsigned int idx = locally_owned.index_within_set (local_dof_indices[i]);
- if (new_indices[idx] == DoFHandler<dim>::invalid_dof_index)
+ if (new_indices[idx] == numbers::invalid_dof_index)
{
new_indices[idx] = locally_owned.nth_index_in_set (next_free);
next_free++;
hierarchical (DoFHandler<dim> &dof_handler)
{
std::vector<types::global_dof_index> renumbering (dof_handler.n_locally_owned_dofs(),
- DoFHandler<dim>::invalid_dof_index);
+ numbers::invalid_dof_index);
typename DoFHandler<dim>::level_cell_iterator cell;
const std::vector<bool> &selected_dofs)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_sort_selected_dofs_back(renumbering, dof_handler, selected_dofs);
dof_handler.renumber_dofs(renumbering);
ExcNotInitialized());
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(level),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_sort_selected_dofs_back(renumbering, dof_handler, selected_dofs, level);
dof_handler.renumber_dofs(level, renumbering);
random (DoFHandlerType &dof_handler)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_random(renumbering, dof_handler);
dof_handler.renumber_dofs(renumbering);
subdomain_wise (DoFHandlerType &dof_handler)
{
std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
compute_subdomain_wise(renumbering, dof_handler);
dof_handler.renumber_dofs(renumbering);
{
mapping.clear ();
mapping.insert (mapping.end(), dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
std::vector<types::global_dof_index> dofs_on_face;
dofs_on_face.reserve (max_dofs_per_face(dof_handler));
cell->face(f)->get_dof_indices (dofs_on_face,
cell->active_fe_index());
for (unsigned int i=0; i<dofs_per_face; ++i)
- if (mapping[dofs_on_face[i]] == DoFHandlerType::invalid_dof_index)
+ if (mapping[dofs_on_face[i]] == numbers::invalid_dof_index)
mapping[dofs_on_face[i]] = next_boundary_index++;
}
mapping.clear ();
mapping.insert (mapping.end(), dof_handler.n_dofs(),
- DoFHandlerType::invalid_dof_index);
+ numbers::invalid_dof_index);
// return if there is nothing to do
if (boundary_ids.size() == 0)
dofs_on_face.resize (dofs_per_face);
cell->face(f)->get_dof_indices (dofs_on_face, cell->active_fe_index());
for (unsigned int i=0; i<dofs_per_face; ++i)
- if (mapping[dofs_on_face[i]] == DoFHandlerType::invalid_dof_index)
+ if (mapping[dofs_on_face[i]] == numbers::invalid_dof_index)
mapping[dofs_on_face[i]] = next_boundary_index++;
}
// first construct the inverse mapping of weight_mapping
std::vector<types::global_dof_index> inverse_weight_mapping (n_global_parm_dofs,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (types::global_dof_index i=0; i<weight_mapping.size(); ++i)
{
const types::global_dof_index parameter_dof = weight_mapping[i];
if (parameter_dof != numbers::invalid_dof_index)
{
Assert (parameter_dof < n_global_parm_dofs, ExcInternalError());
- Assert ((inverse_weight_mapping[parameter_dof] == DoFHandler<dim,spacedim>::invalid_dof_index),
+ Assert ((inverse_weight_mapping[parameter_dof] == numbers::invalid_dof_index),
ExcInternalError());
inverse_weight_mapping[parameter_dof] = i;
types::global_dof_index max_element = 0;
for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
i!=dof_to_boundary_mapping.end(); ++i)
- if ((*i != DoFHandlerType::invalid_dof_index) &&
+ if ((*i != numbers::invalid_dof_index) &&
(*i > max_element))
max_element = *i;
AssertDimension (max_element, sparsity.n_rows()-1);
types::global_dof_index max_element = 0;
for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
i!=dof_to_boundary_mapping.end(); ++i)
- if ((*i != DoFHandlerType::invalid_dof_index) &&
+ if ((*i != numbers::invalid_dof_index) &&
(*i > max_element))
max_element = *i;
AssertDimension (max_element, sparsity.n_rows()-1);
// set up the linked lists for
// each of the vertices
dof_handler.vertex_dofs.resize (vertex_slots_needed,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (unsigned int v=0; v<dof_handler.tria->n_vertices(); ++v)
if (dof_handler.tria->vertex_used(v) == true)
{
if (fe.dofs_per_vertex > 0)
for (unsigned int vertex=0; vertex<GeometryInfo<1>::vertices_per_cell; ++vertex)
if (cell->vertex_dof_index(vertex, 0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_vertex; ++d, ++next_free_dof)
cell->set_vertex_dof_index (vertex, d, next_free_dof, fe_index);
if (fe.dofs_per_line > 0)
{
Assert ((cell->dof_index(0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index),
+ numbers::invalid_dof_index),
ExcInternalError());
for (unsigned int d=0; d<fe.dofs_per_line; ++d, ++next_free_dof)
if (fe.dofs_per_vertex > 0)
for (unsigned int vertex=0; vertex<GeometryInfo<2>::vertices_per_cell; ++vertex)
if (cell->vertex_dof_index(vertex, 0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_vertex; ++d, ++next_free_dof)
cell->set_vertex_dof_index (vertex, d, next_free_dof, fe_index);
line = cell->line(l);
if (line->dof_index(0,fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_line; ++d, ++next_free_dof)
line->set_dof_index (d, next_free_dof, fe_index);
}
if (fe.dofs_per_quad > 0)
{
Assert ((cell->dof_index(0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index),
+ numbers::invalid_dof_index),
ExcInternalError());
for (unsigned int d=0; d<fe.dofs_per_quad; ++d, ++next_free_dof)
if (fe.dofs_per_vertex > 0)
for (unsigned int vertex=0; vertex<GeometryInfo<3>::vertices_per_cell; ++vertex)
if (cell->vertex_dof_index(vertex, 0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_vertex; ++d, ++next_free_dof)
cell->set_vertex_dof_index (vertex, d, next_free_dof, fe_index);
line = cell->line(l);
if (line->dof_index(0,fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_line; ++d, ++next_free_dof)
line->set_dof_index (d, next_free_dof, fe_index);
}
quad = cell->quad(q);
if (quad->dof_index(0,fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index)
+ numbers::invalid_dof_index)
for (unsigned int d=0; d<fe.dofs_per_quad; ++d, ++next_free_dof)
quad->set_dof_index (d, next_free_dof, fe_index);
}
if (fe.dofs_per_hex > 0)
{
Assert ((cell->dof_index(0, fe_index) ==
- DoFHandler<dim,spacedim>::invalid_dof_index),
+ numbers::invalid_dof_index),
ExcInternalError());
for (unsigned int d=0; d<fe.dofs_per_hex; ++d, ++next_free_dof)
dof_handler.levels[level]->dof_indices
= std::vector<types::global_dof_index> (next_free_dof,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels[level]->cell_dof_indices_cache
= std::vector<types::global_dof_index> (cache_size,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
// safety check: make sure that
dof_handler.levels[level]->dof_indices
= std::vector<types::global_dof_index> (next_free_dof,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels[level]->cell_dof_indices_cache
= std::vector<types::global_dof_index> (cache_size,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
// safety check: make sure that
(unsigned int)(-1));
dof_handler.faces->lines.dofs
= std::vector<types::global_dof_index> (n_line_slots,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
// with the memory now
// allocated, loop over the
dof_handler.levels[level]->dof_indices
= std::vector<types::global_dof_index> (next_free_dof,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
dof_handler.levels[level]->cell_dof_indices_cache
= std::vector<types::global_dof_index> (cache_size,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
// safety check: make sure that
(unsigned int)(-1));
dof_handler.faces->quads.dofs
= std::vector<types::global_dof_index> (n_quad_slots,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
}
// with the memory now
// set up the linked lists for
// each of the lines
dof_handler.faces->lines.dofs.resize (line_slots_needed,
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
for (unsigned int line=0; line<dof_handler.tria->n_raw_lines(); ++line)
if (line_is_used[line] == true)
{
local_dofs.reserve (DoFTools::max_dofs_per_face(dof));
std::fill (local_dofs.begin (),
local_dofs.end (),
- DoFHandler<dim,spacedim>::invalid_dof_index);
+ numbers::invalid_dof_index);
// First, deal with the simpler case when we have to identify all boundary dofs
if (component_mask.n_selected_components(n_components) == n_components)
<< ", DoFs=";
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
{
- Assert (local_dof_indices[i] != DoFHandler<dim>::invalid_dof_index,
+ Assert (local_dof_indices[i] != numbers::invalid_dof_index,
ExcInternalError());
deallog << local_dof_indices[i] << ' ';
}
boundary_ids.insert (0);
DoFTools::map_dof_to_boundary_indices (dof_handler, map);
for (unsigned int i=0; i<map.size(); ++i)
- deallog << (map[i] == DoFHandler<dim>::invalid_dof_index ?
+ deallog << (map[i] == numbers::invalid_dof_index ?
-1 : static_cast<signed int>(map[i]))
<< " ";
deallog << std::endl;
boundary_ids.insert (1);
DoFTools::map_dof_to_boundary_indices (dof_handler, map);
for (unsigned int i=0; i<map.size(); ++i)
- deallog << (map[i] == DoFHandler<dim>::invalid_dof_index ?
+ deallog << (map[i] == numbers::invalid_dof_index ?
-1 : static_cast<signed int>(map[i]))
<< " ";
deallog << std::endl;
An error occurred in line <1344> of file </scratch/deal-trunk/deal.II/source/dofs/dof_handler_policy.cc> in function
void dealii::internal::DoFHandler::Policy::{anonymous}::set_mg_dofindices_recursively(const dealii::parallel::distributed::Triangulation<dim, spacedim>&, const typename dealii::internal::p4est::types<dim>::quadrant&, const typename dealii::DoFHandler<dim, spacedim>::level_cell_iterator&, const typename dealii::internal::p4est::types<dim>::quadrant&, unsigned int*, unsigned int) [with int dim = 2; int spacedim = 2; typename dealii::internal::p4est::types<dim>::quadrant = p4est_quadrant; typename dealii::DoFHandler<dim, spacedim>::level_cell_iterator = dealii::TriaIterator<dealii::DoFCellAccessor<dealii::DoFHandler<2>, true> >]
The violated condition was:
- (dof_indices[i] == (DoFHandler<dim,spacedim>::invalid_dof_index)) || (dof_indices[i]==dofs[i])
+ (dof_indices[i] == (numbers::invalid_dof_index)) || (dof_indices[i]==dofs[i])
The name and call sequence of the exception was:
ExcInternalError()
Additional Information:
std::sort(local_dof_indices.begin(), local_dof_indices.end());
//macros are evil...
- types::global_dof_index invalid_dofindex = DoFHandler<dim,dim>::invalid_dof_index;
+ types::global_dof_index invalid_dofindex = numbers::invalid_dof_index;
Assert((*local_dof_indices.rbegin())!=invalid_dofindex, ExcInternalError());
}
cell->get_dof_indices (local_dof_indices);
for (std::vector<types::global_dof_index>::iterator it=local_dof_indices.begin(); it!= local_dof_indices.end(); ++it)
{
- types::global_dof_index invalid_dofindex = DoFHandler<dim,dim>::invalid_dof_index;
+ types::global_dof_index invalid_dofindex = numbers::invalid_dof_index;
Assert(*it!=invalid_dofindex, ExcInternalError());
control_dof_set.insert(*it);
}
projects / dealii.git / commitdiff