// count how much space we need
// on each level and set the
- // dof_*_index_offset
+ // dof_*_offsets
// data. initially set the latter
// to an invalid index, and only
// later set it to something
// reasonable for active cells
for (unsigned int level=0; level<tria->n_levels(); ++level)
{
- levels[level]->dof_line_index_offset
+ levels[level]->line_dof_offsets
= std::vector<unsigned int> (tria->n_raw_lines(level),
invalid_dof_index);
cell!=end_active(level); ++cell)
if (!cell->has_children())
{
- levels[level]->dof_line_index_offset[cell->index()] = next_free_line_dof;
+ levels[level]->line_dof_offsets[cell->index()] = next_free_line_dof;
next_free_line_dof +=
(*finite_elements)[cell->active_fe_index()].dofs_per_line;
}
// the number of DoFs we
// allocated is actually correct
// (above we have also set the
- // dof_*_index_offset field, so
+ // dof_*_offsets field, so
// we couldn't use this simpler
// algorithm)
#ifdef DEBUG
Assert (levels[level]->line_dofs.size() == n_line_dofs, ExcInternalError());
Assert (static_cast<unsigned int>
- (std::count (levels[level]->dof_line_index_offset.begin(),
- levels[level]->dof_line_index_offset.end(),
+ (std::count (levels[level]->line_dof_offsets.begin(),
+ levels[level]->line_dof_offsets.end(),
invalid_dof_index))
==
tria->n_raw_lines(level) - tria->n_active_lines(level),
// count how much space we need
// on each level for the quad
// dofs and set the
- // dof_*_index_offset
+ // dof_*_offsets
// data. initially set the latter
// to an invalid index, and only
// later set it to something
// reasonable for active cells
for (unsigned int level=0; level<tria->n_levels(); ++level)
{
- levels[level]->dof_quad_index_offset
+ levels[level]->quad_dof_offsets
= std::vector<unsigned int> (tria->n_raw_quads(level),
invalid_dof_index);
cell!=end_active(level); ++cell)
if (!cell->has_children())
{
- levels[level]->dof_quad_index_offset[cell->index()]
+ levels[level]->quad_dof_offsets[cell->index()]
= next_free_quad_dof;
next_free_quad_dof
+= (*finite_elements)[cell->active_fe_index()].dofs_per_quad;
// the number of DoFs we
// allocated is actually correct
// (above we have also set the
- // dof_*_index_offset field, so
+ // dof_*_offsets field, so
// we couldn't use this simpler
// algorithm)
#ifdef DEBUG
Assert (levels[level]->quad_dofs.size() == n_quad_dofs,
ExcInternalError());
Assert (static_cast<unsigned int>
- (std::count (levels[level]->dof_quad_index_offset.begin(),
- levels[level]->dof_quad_index_offset.end(),
+ (std::count (levels[level]->quad_dof_offsets.begin(),
+ levels[level]->quad_dof_offsets.end(),
invalid_dof_index))
==
tria->n_raw_quads(level) - tria->n_active_quads(level),
// non-invalid value later on
for (unsigned int level=0; level<tria->n_levels(); ++level)
{
- levels[level]->dof_line_index_offset
+ levels[level]->line_dof_offsets
= std::vector<unsigned int> (tria->n_raw_lines(level),
invalid_dof_index);
levels[level]->line_dofs
(cell->active_fe_index() == cell->neighbor(face)->active_fe_index())))
{
levels[cell->level()]
- ->dof_line_index_offset[cell->face(face)->index()]
+ ->line_dof_offsets[cell->face(face)->index()]
= next_free_line_slot[cell->level()];
// set first slot
else
{
levels[cell->level()]
- ->dof_line_index_offset[cell->face(face)->index()]
+ ->line_dof_offsets[cell->face(face)->index()]
= next_free_line_slot[cell->level()];
// set first slot
// count how much space we need
// on each level and set the
- // dof_*_index_offset
+ // dof_*_offsets
// data. initially set the latter
// to an invalid index, and only
// later set it to something
// reasonable for active cells
for (unsigned int level=0; level<tria->n_levels(); ++level)
{
- levels[level]->dof_hex_index_offset
+ levels[level]->hex_dof_offsets
= std::vector<unsigned int> (tria->n_raw_hexs(level),
invalid_dof_index);
cell!=end_active(level); ++cell)
if (!cell->has_children())
{
- levels[level]->dof_hex_index_offset[cell->index()] = next_free_hex_dof;
+ levels[level]->hex_dof_offsets[cell->index()] = next_free_hex_dof;
next_free_hex_dof +=
(*finite_elements)[cell->active_fe_index()].dofs_per_hex;
}
// the number of DoFs we
// allocated is actually correct
// (above we have also set the
- // dof_*_index_offset field, so
+ // dof_*_offsets field, so
// we couldn't use this simpler
// algorithm)
#ifdef DEBUG
Assert (levels[level]->hex_dofs.size() == n_hex_dofs, ExcInternalError());
Assert (static_cast<unsigned int>
- (std::count (levels[level]->dof_hex_index_offset.begin(),
- levels[level]->dof_hex_index_offset.end(),
+ (std::count (levels[level]->hex_dof_offsets.begin(),
+ levels[level]->hex_dof_offsets.end(),
invalid_dof_index))
==
tria->n_raw_hexs(level) - tria->n_active_hexs(level),
{
Assert (fe_index == this->active_fe_indices[line_index],
ExcMessage ("FE index does not match that of the present cell"));
- return line_dofs[dof_line_index_offset[line_index]+local_index];
+ return line_dofs[line_dof_offsets[line_index]+local_index];
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_line_index_offset[line_index];
+ const unsigned int starting_offset = line_dof_offsets[line_index];
const unsigned int *pointer = &line_dofs[starting_offset];
while (true)
{
{
Assert (fe_index == this->active_fe_indices[line_index],
ExcMessage ("FE index does not match that of the present cell"));
- line_dofs[dof_line_index_offset[line_index]+local_index] = global_index;
+ line_dofs[line_dof_offsets[line_index]+local_index] = global_index;
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_line_index_offset[line_index];
+ const unsigned int starting_offset = line_dof_offsets[line_index];
unsigned int *pointer = &line_dofs[starting_offset];
while (true)
{
{
Assert (fe_index == this->active_fe_indices[quad_index],
ExcMessage ("FE index does not match that of the present cell"));
- return quad_dofs[dof_quad_index_offset[quad_index]+local_index];
+ return quad_dofs[quad_dof_offsets[quad_index]+local_index];
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_quad_index_offset[quad_index];
+ const unsigned int starting_offset = quad_dof_offsets[quad_index];
const unsigned int *pointer = &quad_dofs[starting_offset];
while (true)
{
{
Assert (fe_index == this->active_fe_indices[quad_index],
ExcMessage ("FE index does not match that of the present cell"));
- quad_dofs[dof_quad_index_offset[quad_index]+local_index] = global_index;
+ quad_dofs[quad_dof_offsets[quad_index]+local_index] = global_index;
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_quad_index_offset[quad_index];
+ const unsigned int starting_offset = quad_dof_offsets[quad_index];
unsigned int *pointer = &quad_dofs[starting_offset];
while (true)
{
{
Assert (fe_index == this->active_fe_indices[hex_index],
ExcMessage ("FE index does not match that of the present cell"));
- return hex_dofs[dof_hex_index_offset[hex_index]+local_index];
+ return hex_dofs[hex_dof_offsets[hex_index]+local_index];
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_hex_index_offset[hex_index];
+ const unsigned int starting_offset = hex_dof_offsets[hex_index];
const unsigned int *pointer = &hex_dofs[starting_offset];
while (true)
{
{
Assert (fe_index == this->active_fe_indices[hex_index],
ExcMessage ("FE index does not match that of the present cell"));
- hex_dofs[dof_hex_index_offset[hex_index]+local_index] = global_index;
+ hex_dofs[hex_dof_offsets[hex_index]+local_index] = global_index;
}
else
{
// an exception if we can't
// find a set for this
// particular fe_index
- const unsigned int starting_offset = dof_hex_index_offset[hex_index];
+ const unsigned int starting_offset = hex_dof_offsets[hex_index];
unsigned int *pointer = &hex_dofs[starting_offset];
while (true)
{