// used() is called anyway, even if
// state==IteratorState::past_the_end, and will then
// throw the exception!
- if (state() != IteratorState::past_the_end)
- Assert (accessor.used(),
+ if (this->state() != IteratorState::past_the_end)
+ Assert (this->accessor.used(),
ExcAssignmentOfUnusedObject());
#endif
};
// has_children() is called anyway, even if
// state==IteratorState::past_the_end, and will then
// throw the exception!
- if (state() != IteratorState::past_the_end)
- Assert (accessor.has_children()==false,
+ if (this->state() != IteratorState::past_the_end)
+ Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
};
// state==IteratorState::past_the_end, and will then
// throw the exception!
if (this->state() != IteratorState::past_the_end)
- Assert (accessor.used(),
+ Assert (this->accessor.used(),
ExcAssignmentOfUnusedObject());
#endif
return *this;
// state==IteratorState::past_the_end, and will then
// throw the exception!
if (this->state() != IteratorState::past_the_end)
- Assert (accessor.used() && accessor.has_children()==false,
+ Assert (this->accessor.used() && accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
return *this;
// state==IteratorState::past_the_end, and will then
// throw the exception!
if (this->state() != IteratorState::past_the_end)
- Assert (accessor.has_children()==false,
+ Assert (this->accessor.has_children()==false,
ExcAssignmentOfInactiveObject());
#endif
return *this;
void DoFObjectAccessor<1, dim>::set_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (dof_handler->selected_fe != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->selected_fe->dofs_per_line,
+ Assert (this->dof_handler->selected_fe != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->selected_fe->dofs_per_line,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_line));
- dof_handler->levels[present_level]
- ->line_dofs[present_index*dof_handler->selected_fe->dofs_per_line+i] = index;
+ this->dof_handler->levels[this->present_level]
+ ->line_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_line+i] = index;
};
// qualified exception names
typedef DoFAccessor<dim> BaseClass;
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename BaseClass::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
- Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+ Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
- const unsigned int dof_number = (vertex_index(vertex) *
- dof_handler->selected_fe->dofs_per_vertex +
+ const unsigned int dof_number = (this->vertex_index(vertex) *
+ this->dof_handler->selected_fe->dofs_per_vertex +
i);
- dof_handler->vertex_dofs[dof_number] = index;
+ this->dof_handler->vertex_dofs[dof_number] = index;
};
// qualified exception names
typedef DoFAccessor<dim> BaseClass;
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename BaseClass::ExcInvalidObject());
- Assert (local_source.size() == (2*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
dof_handler->get_fe().dofs_per_line),
typename BaseClass::ExcVectorDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.size(),
+ Assert (this->dof_handler->n_dofs() == global_destination.size(),
typename BaseClass::ExcVectorDoesNotMatch());
const unsigned int n_dofs = local_source.size();
// qualified exception names
typedef DoFAccessor<dim> BaseClass;
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename BaseClass::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename BaseClass::ExcInvalidObject());
- Assert (local_source.m() == (2*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.m() == (2*this->dof_handler->get_fe().dofs_per_vertex +
dof_handler->get_fe().dofs_per_line),
typename BaseClass::ExcVectorDoesNotMatch());
Assert (local_source.m() == local_source.n(),
typename BaseClass::ExcMatrixDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.m(),
+ Assert (this->dof_handler->n_dofs() == global_destination.m(),
typename BaseClass::ExcMatrixDoesNotMatch());
Assert (global_destination.m() == global_destination.n(),
typename BaseClass::ExcMatrixDoesNotMatch());
{
Assert (dim==1, ExcInternalError());
- Assert (dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<1>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<1>::ExcVectorDoesNotMatch());
- Assert (has_children() == false, DoFAccessor<1>::ExcNotActive());
+ Assert (this->has_children() == false, DoFAccessor<1>::ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
typename Vector<number>::iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
{
Assert (dim==1, ExcInternalError());
- Assert (dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<1>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<1>::ExcVectorDoesNotMatch());
- Assert (has_children() == false, DoFAccessor<1>::ExcNotActive());
+ Assert (this->has_children() == false, DoFAccessor<1>::ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
typename Vector<number>::const_iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
void DoFObjectAccessor<2, dim>::set_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->selected_fe->dofs_per_quad,
+ Assert (i<this->dof_handler->selected_fe->dofs_per_quad,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_quad));
- dof_handler->levels[present_level]
- ->quad_dofs[present_index*dof_handler->selected_fe->dofs_per_quad+i] = index;
+ this->dof_handler->levels[this->present_level]
+ ->quad_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_quad+i] = index;
};
const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
- Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+ Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
- const unsigned int dof_number = (vertex_index(vertex) *
- dof_handler->selected_fe->dofs_per_vertex +
+ const unsigned int dof_number = (this->vertex_index(vertex) *
+ this->dof_handler->selected_fe->dofs_per_vertex +
i);
- dof_handler->vertex_dofs[dof_number] = index;
+ this->dof_handler->vertex_dofs[dof_number] = index;
};
void DoFObjectAccessor<2, dim>::
distribute_local_to_global (const Vector<double> &local_source,
Vector<double> &global_destination) const {
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_source.size() == (4*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*dof_handler->get_fe().dofs_per_line +
dof_handler->get_fe().dofs_per_quad),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.size(),
+ Assert (this->dof_handler->n_dofs() == global_destination.size(),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
const unsigned int n_dofs = local_source.size();
void DoFObjectAccessor<2, dim>::
distribute_local_to_global (const FullMatrix<double> &local_source,
SparseMatrix<double> &global_destination) const {
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_source.m() == (4*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.m() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*dof_handler->get_fe().dofs_per_line +
dof_handler->get_fe().dofs_per_quad),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
Assert (local_source.m() == local_source.n(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.m(),
+ Assert (this->dof_handler->n_dofs() == global_destination.m(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
Assert (global_destination.m() == global_destination.n(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
{
Assert (dim==2, ExcInternalError());
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0,
+ Assert (&this->dof_handler->get_fe() != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (has_children() == false, typename DoFAccessor<dim>::
+ Assert (this->has_children() == false, typename DoFAccessor<dim>::
ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
- dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
+ dofs_per_quad = this->dof_handler->get_fe().dofs_per_quad;
typename Vector<number>::iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
{
Assert (dim==2, ExcInternalError());
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0,
+ Assert (&this->dof_handler->get_fe() != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (has_children() == false,
+ Assert (this->has_children() == false,
typename DoFAccessor<dim>::ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
- dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
+ dofs_per_quad = this->dof_handler->get_fe().dofs_per_quad;
typename Vector<number>::const_iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
void DoFObjectAccessor<3, dim>::set_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->selected_fe->dofs_per_hex,
+ Assert (i<this->dof_handler->selected_fe->dofs_per_hex,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_hex));
- dof_handler->levels[present_level]
- ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i] = index;
+ this->dof_handler->levels[this->present_level]
+ ->hex_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_hex+i] = index;
};
const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<8,
ExcIndexRange (i,0,8));
- Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+ Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
- const unsigned int dof_number = (vertex_index(vertex) *
- dof_handler->selected_fe->dofs_per_vertex +
+ const unsigned int dof_number = (this->vertex_index(vertex) *
+ this->dof_handler->selected_fe->dofs_per_vertex +
i);
- dof_handler->vertex_dofs[dof_number] = index;
+ this->dof_handler->vertex_dofs[dof_number] = index;
};
distribute_local_to_global (const Vector<double> &local_source,
Vector<double> &global_destination) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_source.size() == (8*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.size() == (8*this->dof_handler->get_fe().dofs_per_vertex +
12*dof_handler->get_fe().dofs_per_line +
6*dof_handler->get_fe().dofs_per_quad +
dof_handler->get_fe().dofs_per_hex),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.size(),
+ Assert (this->dof_handler->n_dofs() == global_destination.size(),
typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
const unsigned int n_dofs = local_source.size();
distribute_local_to_global (const FullMatrix<double> &local_source,
SparseMatrix<double> &global_destination) const
{
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_handler->selected_fe != 0,
+ Assert (this->dof_handler->selected_fe != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
- Assert (local_source.m() == (8*dof_handler->get_fe().dofs_per_vertex +
+ Assert (local_source.m() == (8*this->dof_handler->get_fe().dofs_per_vertex +
12*dof_handler->get_fe().dofs_per_line +
6*dof_handler->get_fe().dofs_per_quad +
dof_handler->get_fe().dofs_per_hex),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
Assert (local_source.m() == local_source.n(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
- Assert (dof_handler->n_dofs() == global_destination.m(),
+ Assert (this->dof_handler->n_dofs() == global_destination.m(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
Assert (global_destination.m() == global_destination.n(),
typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
{
Assert (dim==3, ExcInternalError());
- Assert (dof_handler != 0, DoFAccessor<3>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<3>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<3>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<3>::ExcInvalidObject());
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<3>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<3>::ExcVectorDoesNotMatch());
- Assert (has_children() == false,
+ Assert (this->has_children() == false,
DoFAccessor<3>::ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
typename Vector<number>::iterator next_local_value = local_values.begin();
{
Assert (dim==3, ExcInternalError());
- Assert (dof_handler != 0,
+ Assert (this->dof_handler != 0,
DoFAccessor<3>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0,
+ Assert (&this->dof_handler->get_fe() != 0,
DoFAccessor<3>::ExcInvalidObject());
- Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (local_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<3>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<3>::ExcVectorDoesNotMatch());
- Assert (has_children() == false,
+ Assert (this->has_children() == false,
DoFAccessor<3>::ExcNotActive());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
typename Vector<number>::const_iterator next_local_value=local_values.begin();
TriaIterator<2, DoFObjectAccessor<1,2> >
DoFCellAccessor<2>::face (const unsigned int i) const
{
- return line(i);
+ return this->line(i);
};
#endif
DoFCellAccessor<dim>::get_interpolated_dof_values (const InputVector &values,
Vector<number> &interpolated_values) const
{
- const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
+ const unsigned int dofs_per_cell = this->dof_handler->get_fe().dofs_per_cell;
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (interpolated_values.size() == dofs_per_cell,
DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<dim>::ExcVectorDoesNotMatch());
- if (!has_children())
+ if (!this->has_children())
// if this cell has no children: simply
// return the exact values on this cell
get_dof_values (values, interpolated_values);
tmp1);
// interpolate these to the mother
// cell
- dof_handler->get_fe().restrict(child).vmult (tmp2, tmp1);
+ this->dof_handler->get_fe().restrict(child).vmult (tmp2, tmp1);
// now write those entries in tmp2
// which are != 0 into the output
DoFCellAccessor<dim>::set_dof_values_by_interpolation (const Vector<number> &local_values,
OutputVector &values) const
{
- const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
+ const unsigned int dofs_per_cell = this->dof_handler->get_fe().dofs_per_cell;
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (local_values.size() == dofs_per_cell,
DoFAccessor<dim>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<dim>::ExcVectorDoesNotMatch());
- if (!has_children())
+ if (!this->has_children())
// if this cell has no children: simply
// set the values on this cell
set_dof_values (local_values, values);
{
// prolong the given data
// to the present cell
- dof_handler->get_fe().prolongate(child).vmult (tmp, local_values);
+ this->dof_handler->get_fe().prolongate(child).vmult (tmp, local_values);
this->child(child)->set_dof_values_by_interpolation (tmp, values);
};
};
{
const FaceData &face = faces[rot][face_no]->second;
- for (unsigned int face_rot=0; face_rot<rotational_states_of_faces-1; ++face_rot)
+ for (unsigned int face_rot=0; face_rot<this->rotational_states_of_faces-1; ++face_rot)
{
const FaceData &reverse_face = face.reverse_faces[face_rot]->second;
if (reverse_face.use_count != 0)
// stack
rotation_states.pop_back();
};
- Assert (last_rotation_state < rotational_states_of_cells, ExcInternalError());
+ Assert (last_rotation_state < this->rotational_states_of_cells, ExcInternalError());
// now we will have to find out
// whether we can try the last cell
// we have popped from the stack in
// another rotation state, or will
// have to backtrack further:
- if (last_rotation_state < rotational_states_of_cells-1)
+ if (last_rotation_state < this->rotational_states_of_cells-1)
{
// possible. push that state to
// the stack and leave
// that have already been
// tried:
for (unsigned int neighbor_rot=old_rotation_state+1;
- neighbor_rot<rotational_states_of_cells; ++neighbor_rot)
+ neighbor_rot<this->rotational_states_of_cells; ++neighbor_rot)
{
// first, if the
// neighbor itself does
// orientation
cells[neighbor_no].mark_faces_used (neighbor_rot);
- for (unsigned int cell_rot=0; cell_rot<rotational_states_of_cells; ++cell_rot)
+ for (unsigned int cell_rot=0; cell_rot<this->rotational_states_of_cells; ++cell_rot)
if (cells[cell_no].check_consistency (cell_rot) == true)
{
// ah, see,
// no, doesn't work. see if
// we can rotate the top
// cell so that it works
- if (rotation_states.back()+1 < rotational_states_of_cells)
+ if (rotation_states.back()+1 < this->rotational_states_of_cells)
{
// yes, can be
// done. then do so and
// first save flags
refine_flags.push_back (std::vector<bool>());
coarsen_flags.push_back (std::vector<bool>());
- save_refine_flags (refine_flags.back());
- save_coarsen_flags (coarsen_flags.back());
+ this->save_refine_flags (refine_flags.back());
+ this->save_coarsen_flags (coarsen_flags.back());
// then refine triangulation
Triangulation<dim>::execute_coarsening_and_refinement ();
Assert(step<refine_flags.size()+1,
ExcDimensionMismatch(step, refine_flags.size()+1));
- load_refine_flags (refine_flags[step-1]);
- load_coarsen_flags (coarsen_flags[step-1]);
+ this->load_refine_flags (refine_flags[step-1]);
+ this->load_coarsen_flags (coarsen_flags[step-1]);
Triangulation<dim>::execute_coarsening_and_refinement ();
};
void
PersistentTriangulation<dim>::copy_triangulation (const Triangulation<dim> &old_grid)
{
- clear ();
+ this->clear ();
coarse_grid = &old_grid;
refine_flags.clear ();
coarsen_flags.clear ();
for (unsigned int i=0; i<n_flag_levels; ++i)
{
- write_bool_vector (mn_tria_refine_flags_begin, refine_flags[i],
+ this->write_bool_vector (mn_tria_refine_flags_begin, refine_flags[i],
mn_tria_refine_flags_end, out);
- write_bool_vector (mn_tria_coarsen_flags_begin, coarsen_flags[i],
+ this->write_bool_vector (mn_tria_coarsen_flags_begin, coarsen_flags[i],
mn_tria_coarsen_flags_end, out);
}
{
refine_flags.push_back (std::vector<bool>());
coarsen_flags.push_back (std::vector<bool>());
- read_bool_vector (mn_tria_refine_flags_begin, refine_flags.back(),
+ this->read_bool_vector (mn_tria_refine_flags_begin, refine_flags.back(),
mn_tria_refine_flags_end, in);
- read_bool_vector (mn_tria_coarsen_flags_begin, coarsen_flags.back(),
+ this->read_bool_vector (mn_tria_coarsen_flags_begin, coarsen_flags.back(),
mn_tria_coarsen_flags_end, in);
}
template <int dim>
void TriaObjectAccessor<1, dim>::set (const Line &line) const
{
- tria->levels[present_level]->lines.lines[present_index] = line;
+ this->tria->levels[this->present_level]->lines.lines[this->present_index] = line;
};
int TriaObjectAccessor<1, dim>::vertex_index (const unsigned int i) const
{
Assert (i<2, ExcIndexRange(i,0,2));
- return tria->levels[present_level]->lines.lines[present_index].vertex (i);
+ return this->tria->levels[this->present_level]->lines.lines[this->present_index].vertex (i);
};
Point<dim> &
TriaObjectAccessor<1, dim>::vertex (const unsigned int i) const
{
- return tria->vertices[vertex_index(i)];
+ return this->tria->vertices[vertex_index(i)];
};
template <int dim>
void TriaObjectAccessor<1, dim>::set_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->lines.used[present_index] = true;
+ this->tria->levels[this->present_level]->lines.used[this->present_index] = true;
};
template <int dim>
void TriaObjectAccessor<1, dim>::clear_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->lines.used[present_index] = false;
+ this->tria->levels[this->present_level]->lines.used[this->present_index] = false;
};
void TriaObjectAccessor<1, dim>::set_user_pointer (void *p) const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->lines.user_pointers[present_index] = p;
+ this->tria->levels[this->present_level]->lines.user_pointers[this->present_index] = p;
};
void TriaObjectAccessor<1, dim>::clear_user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->lines.user_pointers[present_index] = 0;
+ this->tria->levels[this->present_level]->lines.user_pointers[this->present_index] = 0;
};
void * TriaObjectAccessor<1, dim>::user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->lines.user_pointers[present_index];
+ return this->tria->levels[this->present_level]->lines.user_pointers[this->present_index];
};
(!has_children() && (index>=0)),
typename TriaAccessor<dim>::ExcCantSetChildren(index));
- tria->levels[present_level]->lines.children[present_index] = index;
+ this->tria->levels[this->present_level]->lines.children[this->present_index] = index;
};
Assert (dim>=2, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->lines.material_id[present_index];
+ return this->tria->levels[this->present_level]->lines.material_id[this->present_index];
};
Assert (dim>=2, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->lines.material_id[present_index] = boundary_ind;
+ this->tria->levels[this->present_level]->lines.material_id[this->present_index] = boundary_ind;
};
template <int dim>
void TriaObjectAccessor<2, dim>::set (const Quad &quad) const
{
- tria->levels[present_level]->quads.quads[present_index] = quad;
+ this->tria->levels[this->present_level]->quads.quads[this->present_index] = quad;
};
Point<dim> &
TriaObjectAccessor<2, dim>::vertex (const unsigned int i) const
{
- return tria->vertices[vertex_index(i)];
+ return this->tria->vertices[vertex_index(i)];
};
void
TriaObjectAccessor<2, dim>::set_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->quads.used[present_index] = true;
+ this->tria->levels[this->present_level]->quads.used[this->present_index] = true;
};
template <int dim>
void TriaObjectAccessor<2, dim>::clear_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->quads.used[present_index] = false;
+ this->tria->levels[this->present_level]->quads.used[this->present_index] = false;
};
void TriaObjectAccessor<2, dim>::set_user_pointer (void *p) const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->quads.user_pointers[present_index] = p;
+ this->tria->levels[this->present_level]->quads.user_pointers[this->present_index] = p;
};
void TriaObjectAccessor<2, dim>::clear_user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->quads.user_pointers[present_index] = 0;
+ this->tria->levels[this->present_level]->quads.user_pointers[this->present_index] = 0;
};
void * TriaObjectAccessor<2, dim>::user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->quads.user_pointers[present_index];
+ return this->tria->levels[this->present_level]->quads.user_pointers[this->present_index];
};
(!has_children() && (index>=0)),
typename TriaAccessor<dim>::ExcCantSetChildren(index));
- tria->levels[present_level]->quads.children[present_index] = index;
+ this->tria->levels[this->present_level]->quads.children[this->present_index] = index;
};
Assert (dim>=3, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->quads.material_id[present_index];
+ return this->tria->levels[this->present_level]->quads.material_id[this->present_index];
};
Assert (dim>=3, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->quads.material_id[present_index] = boundary_ind;
+ this->tria->levels[this->present_level]->quads.material_id[this->present_index] = boundary_ind;
};
template <int dim>
void TriaObjectAccessor<3, dim>::set (const Hexahedron &hex) const
{
- tria->levels[present_level]->hexes.hexes[present_index] = hex;
+ this->tria->levels[this->present_level]->hexes.hexes[this->present_index] = hex;
};
Point<dim> &
TriaObjectAccessor<3, dim>::vertex (const unsigned int i) const
{
- return tria->vertices[vertex_index(i)];
+ return this->tria->vertices[vertex_index(i)];
};
template <int dim>
void TriaObjectAccessor<3, dim>::set_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->hexes.used[present_index] = true;
+ this->tria->levels[this->present_level]->hexes.used[this->present_index] = true;
};
template <int dim>
void TriaObjectAccessor<3, dim>::clear_used_flag () const
{
- Assert (state() == IteratorState::valid,
+ Assert (this->state() == IteratorState::valid,
typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
- tria->levels[present_level]->hexes.used[present_index] = false;
+ this->tria->levels[this->present_level]->hexes.used[this->present_index] = false;
};
void TriaObjectAccessor<3, dim>::set_user_pointer (void *p) const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->hexes.user_pointers[present_index] = p;
+ this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index] = p;
};
void TriaObjectAccessor<3, dim>::clear_user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->hexes.user_pointers[present_index] = 0;
+ this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index] = 0;
};
void * TriaObjectAccessor<3, dim>::user_pointer () const
{
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->hexes.user_pointers[present_index];
+ return this->tria->levels[this->present_level]->hexes.user_pointers[this->present_index];
};
(!has_children() && (index>=0)),
typename TriaAccessor<dim>::ExcCantSetChildren(index));
- tria->levels[present_level]->hexes.children[present_index] = index;
+ this->tria->levels[this->present_level]->hexes.children[this->present_index] = index;
};
Assert (dim<4, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->hexes.material_id[present_index];
+ return this->tria->levels[this->present_level]->hexes.material_id[this->present_index];
};
Assert (dim<4, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->hexes.material_id[present_index] = boundary_ind;
+ this->tria->levels[this->present_level]->hexes.material_id[this->present_index] = boundary_ind;
};
template <>
unsigned char CellAccessor<2>::material_id () const
{
- Assert (used(), TriaAccessor<2>::ExcCellNotUsed());
- return tria->levels[present_level]->quads.material_id[present_index];
+ Assert (this->used(), TriaAccessor<2>::ExcCellNotUsed());
+ return this->tria->levels[this->present_level]->quads.material_id[this->present_index];
};
template <>
void CellAccessor<2>::set_material_id (const unsigned char mat_id) const
{
- Assert (used(), TriaAccessor<2>::ExcCellNotUsed());
- tria->levels[present_level]->quads.material_id[present_index]
+ Assert (this->used(), TriaAccessor<2>::ExcCellNotUsed());
+ this->tria->levels[this->present_level]->quads.material_id[this->present_index]
= mat_id;
};
{
// vector from the first vertex
// of the line to the point
- const Point<2> to_p = p-vertex(f);
+ const Point<2> to_p = p-this->vertex(f);
// vector describing the line
- const Point<2> face = vertex((f+1)%4)-vertex(f);
+ const Point<2> face = this->vertex((f+1)%4)-vertex(f);
// if we rotate the face vector
// by 90 degrees to the left
template <int dim>
unsigned int CellAccessor<dim>::subdomain_id () const
{
- Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- return tria->levels[present_level]->subdomain_ids[present_index];
+ Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+ return this->tria->levels[this->present_level]->subdomain_ids[this->present_index];
};
void
CellAccessor<dim>::set_subdomain_id (const unsigned int new_subdomain_id) const
{
- Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
- tria->levels[present_level]->subdomain_ids[present_index]
+ Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+ this->tria->levels[this->present_level]->subdomain_ids[this->present_index]
= new_subdomain_id;
};
if (pointer.state() == IteratorState::valid)
{
- tria->levels[present_level]->
- neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first
+ this->tria->levels[this->present_level]->
+ neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].first
= pointer->present_level;
- tria->levels[present_level]->
- neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second
+ this->tria->levels[this->present_level]->
+ neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].second
= pointer->present_index;
}
else
{
- tria->levels[present_level]->
- neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first
+ this->tria->levels[this->present_level]->
+ neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].first
= -1;
- tria->levels[present_level]->
- neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second
+ this->tria->levels[this->present_level]->
+ neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].second
= -1;
};
};
{
// make sure that the neighbor is
// not on a coarser level
- Assert (neighbor_level(neighbor) == present_level,
+ Assert (neighbor_level(neighbor) == this->present_level,
typename TriaAccessor<dim>::ExcNeighborIsCoarser());
Assert (neighbor < GeometryInfo<dim>::faces_per_cell,
typename TriaAccessor<dim>::ExcInvalidNeighbor(neighbor));
const unsigned int neighbor_guess
= GeometryInfo<dim>::opposite_face[neighbor];
- if ((neighbor_cell->neighbor_index (neighbor_guess) == present_index) &&
- (neighbor_cell->neighbor_level (neighbor_guess) == present_level))
+ if ((neighbor_cell->neighbor_index (neighbor_guess) == this->present_index) &&
+ (neighbor_cell->neighbor_level (neighbor_guess) == this->present_level))
return neighbor_guess;
else
// if the guess was false, then
// the hard way
{
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- if ((neighbor_cell->neighbor_index (face) == present_index) &&
- (neighbor_cell->neighbor_level (face) == present_level))
+ if ((neighbor_cell->neighbor_index (face) == this->present_index) &&
+ (neighbor_cell->neighbor_level (face) == this->present_level))
return face;
// we should never get here,
{
// make sure that the neighbor is
// on a coarser level
- Assert (neighbor_level(neighbor) < present_level,
+ Assert (neighbor_level(neighbor) < this->present_level,
typename TriaAccessor<dim>::ExcNeighborIsNotCoarser());
Assert (neighbor < GeometryInfo<dim>::faces_per_cell,
typename TriaAccessor<dim>::ExcInvalidNeighbor(neighbor));
template <int dim>
bool CellAccessor<dim>::at_boundary (const unsigned int i) const
{
- Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+ Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
Assert (i<GeometryInfo<dim>::faces_per_cell,
ExcIndexRange (i,0,GeometryInfo<dim>::faces_per_cell));
bool CellAccessor<dim>::has_boundary_lines () const
{
for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
- if (line(l)->at_boundary())
+ if (this->line(l)->at_boundary())
return true;
return false;
// to the plane part of the
// boundary
const Point<dim> line_center = line->center();
- if (line_center(0) == center(0))
+ if (this->line_this->center(0) == center(0))
return line_center;
else
return HyperBallBoundary<dim>::get_new_point_on_line (line);
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const
{
const Point<dim> quad_center = quad->center();
- if (quad_center(0) == center(0))
+ if (this->quad_this->center(0) == center(0))
return quad_center;
else
return HyperBallBoundary<dim>::get_new_point_on_quad (quad);
// to the plane part of the
// boundary
const Point<dim> line_center = line->center();
- if (line_center(0) == center(0))
+ if (this->line_this->center(0) == center(0))
return StraightBoundary<dim>::get_intermediate_points_on_line (line, points);
else
return HyperBallBoundary<dim>::get_intermediate_points_on_line (line, points);
// to the plane part of the
// boundary
const Point<dim> quad_center = quad->center();
- if (quad_center(0) == center(0))
+ if (this->quad_this->center(0) == center(0))
StraightBoundary<dim>::get_intermediate_points_on_quad (quad, points);
else
HyperBallBoundary<dim>::get_intermediate_points_on_quad (quad, points);
// to the plane part of the
// boundary
const Point<dim> quad_center = face->center();
- if (quad_center(0) == center(0))
+ if (this->quad_this->center(0) == center(0))
StraightBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
else
HyperBallBoundary<dim>::get_normals_at_vertices (face, face_vertex_normals);
HyperShellBoundary<dim>::HyperShellBoundary (const Point<dim> ¢er) :
HyperBallBoundary<dim>(center, 0.)
{
- compute_radius_automatically=true;
+ this->compute_radius_automatically=true;
};
template <int dim>
unsigned int MGDoFObjectAccessor<1, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_line,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_line));
- return mg_dof_handler->mg_levels[present_level]
- ->line_dofs[present_index*dof_handler->get_fe().dofs_per_line+i];
+ return this->mg_dof_handler->mg_levels[this->present_level]
+ ->line_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_line+i];
};
void MGDoFObjectAccessor<1, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_line,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_line,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_line));
- mg_dof_handler->mg_levels[present_level]
- ->line_dofs[present_index*dof_handler->get_fe().dofs_per_line+i] = index;
+ this->mg_dof_handler->mg_levels[this->present_level]
+ ->line_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_line+i] = index;
};
unsigned int MGDoFObjectAccessor<1, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- return (mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .get_index (present_level, i, dof_handler->get_fe().dofs_per_vertex));
+ return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
};
const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<2, ExcIndexRange (i,0,2));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .set_index (present_level, i, dof_handler->get_fe().dofs_per_vertex, index);
+ this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
};
void
MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_indices.size() == (2*dof_handler->get_fe().dofs_per_vertex +
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
dof_handler->get_fe().dofs_per_line),
DoFAccessor<dim>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
MGDoFObjectAccessor<1,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- Assert (dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
- Assert (dof_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<1>::ExcInvalidObject());
+ Assert (dof_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<1>::ExcVectorDoesNotMatch());
- Assert (values.size() == dof_handler->n_dofs(),
+ Assert (values.size() == this->dof_handler->n_dofs(),
DoFAccessor<1>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line;
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line;
typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
MGDoFObjectAccessor<1, dim>::child (const unsigned int i) const
{
- TriaIterator<dim,MGDoFObjectAccessor<1, dim> > q (tria,
- present_level+1,
- child_index (i),
- mg_dof_handler);
+ TriaIterator<dim,MGDoFObjectAccessor<1, dim> > q (this->tria,
+ this->present_level+1,
+ this->child_index (i),
+ this->mg_dof_handler);
#ifdef DEBUG
if (q.state() != IteratorState::past_the_end)
template <int dim>
unsigned int MGDoFObjectAccessor<2, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_quad,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_quad));
- return mg_dof_handler->mg_levels[present_level]
- ->quad_dofs[present_index*dof_handler->get_fe().dofs_per_quad+i];
+ return this->mg_dof_handler->mg_levels[this->present_level]
+ ->quad_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_quad+i];
};
void MGDoFObjectAccessor<2, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_quad,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_quad,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_quad));
- mg_dof_handler->mg_levels[present_level]
- ->quad_dofs[present_index*dof_handler->get_fe().dofs_per_quad+i] = index;
+ this->mg_dof_handler->mg_levels[this->present_level]
+ ->quad_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_quad+i] = index;
};
unsigned int MGDoFObjectAccessor<2, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- return (mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .get_index (present_level, i, dof_handler->get_fe().dofs_per_vertex));
+ return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
};
const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .set_index (present_level, i, dof_handler->get_fe().dofs_per_vertex, index);
+ this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
};
void
MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_indices.size() == (4*dof_handler->get_fe().dofs_per_vertex +
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
4*dof_handler->get_fe().dofs_per_line +
dof_handler->get_fe().dofs_per_quad),
DoFAccessor<2>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
MGDoFObjectAccessor<2,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- Assert (dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (dof_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (dof_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<2>::ExcVectorDoesNotMatch());
- Assert (values.size() == mg_dof_handler->n_dofs(present_level),
+ Assert (values.size() == this->mg_dof_handler->n_dofs(this->present_level),
DoFAccessor<2>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
return TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
(
- tria,
- present_level,
- line_index (i),
- mg_dof_handler
+ this->tria,
+ this->present_level,
+ this->line_index (i),
+ this->mg_dof_handler
);
};
TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
MGDoFObjectAccessor<2, dim>::child (const unsigned int i) const
{
- TriaIterator<dim,MGDoFObjectAccessor<2, dim> > q (tria,
- present_level+1,
- child_index (i),
- mg_dof_handler);
+ TriaIterator<dim,MGDoFObjectAccessor<2, dim> > q (this->tria,
+ this->present_level+1,
+ this->child_index (i),
+ this->mg_dof_handler);
#ifdef DEBUG
if (q.state() != IteratorState::past_the_end)
template <int dim>
unsigned int MGDoFObjectAccessor<3, dim>::mg_dof_index (const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_hex,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_hex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_hex));
- return mg_dof_handler->mg_levels[present_level]
- ->hex_dofs[present_index*dof_handler->get_fe().dofs_per_hex+i];
+ return this->mg_dof_handler->mg_levels[this->present_level]
+ ->hex_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_hex+i];
};
void MGDoFObjectAccessor<3, dim>::set_mg_dof_index (const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (i<dof_handler->get_fe().dofs_per_hex,
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (i<this->dof_handler->get_fe().dofs_per_hex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_hex));
- mg_dof_handler->mg_levels[present_level]
- ->hex_dofs[present_index*dof_handler->get_fe().dofs_per_hex+i] = index;
+ this->mg_dof_handler->mg_levels[this->present_level]
+ ->hex_dofs[this->present_index*this->dof_handler->get_fe().dofs_per_hex+i] = index;
};
unsigned int MGDoFObjectAccessor<3, dim>::mg_vertex_dof_index (const unsigned int vertex,
const unsigned int i) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<8, ExcIndexRange (i,0,8));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- return (mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .get_index (present_level, i, dof_handler->get_fe().dofs_per_vertex));
+ return (this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .get_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex));
};
const unsigned int i,
const unsigned int index) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (vertex<4, ExcIndexRange (i,0,4));
- Assert (i<dof_handler->get_fe().dofs_per_vertex,
+ Assert (i<this->dof_handler->get_fe().dofs_per_vertex,
ExcIndexRange (i, 0, dof_handler->get_fe().dofs_per_vertex));
- mg_dof_handler->mg_vertex_dofs[vertex_index(vertex)]
- .set_index (present_level, i, dof_handler->get_fe().dofs_per_vertex, index);
+ this->mg_dof_handler->mg_vertex_dofs[this->vertex_index(vertex)]
+ .set_index (this->present_level, i, this->dof_handler->get_fe().dofs_per_vertex, index);
};
void
MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
- Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
- Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
+ Assert (this->dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+ Assert (dof_indices.size() == (8*this->dof_handler->get_fe().dofs_per_vertex +
12*dof_handler->get_fe().dofs_per_line +
6*dof_handler->get_fe().dofs_per_quad +
dof_handler->get_fe().dofs_per_hex),
DoFAccessor<3>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
std::vector<unsigned int>::iterator next = dof_indices.begin();
MGDoFObjectAccessor<3,dim>::get_mg_dof_values (const Vector<number> &values,
Vector<number> &dof_values) const
{
- Assert (dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (mg_dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (&dof_handler->get_fe() != 0, DoFAccessor<2>::ExcInvalidObject());
- Assert (dof_values.size() == dof_handler->get_fe().dofs_per_cell,
+ Assert (this->dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (this->mg_dof_handler != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (&this->dof_handler->get_fe() != 0, DoFAccessor<2>::ExcInvalidObject());
+ Assert (dof_values.size() == this->dof_handler->get_fe().dofs_per_cell,
DoFAccessor<3>::ExcVectorDoesNotMatch());
- Assert (values.size() == mg_dof_handler->n_dofs(present_level),
+ Assert (values.size() == this->mg_dof_handler->n_dofs(this->present_level),
DoFAccessor<3>::ExcVectorDoesNotMatch());
- const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
- dofs_per_line = dof_handler->get_fe().dofs_per_line,
+ const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+ dofs_per_line = this->dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int d=0; d<dofs_per_quad; ++d)
*next_dof_value++ = values(this->quad(quad)->mg_dof_index(d));
for (unsigned int d=0; d<dofs_per_hex; ++d)
- *next_dof_value++ = values(dof_index(d));
+ *next_dof_value++ = values(this->dof_index(d));
Assert (next_dof_value == dof_values.end(),
ExcInternalError());
return TriaIterator<dim,MGDoFObjectAccessor<1, dim> >
(
- tria,
- present_level,
- line_index (i),
- mg_dof_handler
+ this->tria,
+ this->present_level,
+ this->line_index (i),
+ this->mg_dof_handler
);
};
return TriaIterator<dim,MGDoFObjectAccessor<2, dim> >
(
- tria,
- present_level,
- quad_index (i),
- mg_dof_handler
+ this->tria,
+ this->present_level,
+ this->quad_index (i),
+ this->mg_dof_handler
);
};
template <int dim>
TriaIterator<dim,MGDoFObjectAccessor<3, dim> >
MGDoFObjectAccessor<3, dim>::child (const unsigned int i) const {
- TriaIterator<dim,MGDoFObjectAccessor<3, dim> > q (tria,
- present_level+1,
- child_index (i),
- mg_dof_handler);
+ TriaIterator<dim,MGDoFObjectAccessor<3, dim> > q (this->tria,
+ this->present_level+1,
+ this->child_index (i),
+ this->mg_dof_handler);
#ifdef DEBUG
if (q.state() != IteratorState::past_the_end)
template <int dim>
TriaIterator<dim,MGDoFCellAccessor<dim> >
MGDoFCellAccessor<dim>::neighbor (const unsigned int i) const {
- TriaIterator<dim,MGDoFCellAccessor<dim> > q (tria,
- neighbor_level (i),
- neighbor_index (i),
- mg_dof_handler);
+ TriaIterator<dim,MGDoFCellAccessor<dim> > q (this->tria,
+ this->neighbor_level (i),
+ this->neighbor_index (i),
+ this->mg_dof_handler);
#ifdef DEBUG
if (q.state() != IteratorState::past_the_end)
template <int dim>
TriaIterator<dim,MGDoFCellAccessor<dim> >
MGDoFCellAccessor<dim>::child (const unsigned int i) const {
- TriaIterator<dim,MGDoFCellAccessor<dim> > q (tria,
- present_level+1,
- child_index (i),
- mg_dof_handler);
+ TriaIterator<dim,MGDoFCellAccessor<dim> > q (this->tria,
+ this->present_level+1,
+ this->child_index (i),
+ this->mg_dof_handler);
#ifdef DEBUG
if (q.state() != IteratorState::past_the_end)
MGDoFCellAccessor<2>::face_iterator
MGDoFCellAccessor<2>::face (const unsigned int i) const
{
- return line(i);
+ return this->line(i);
};
#endif
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::begin_raw_line (const unsigned int level) const {
- return raw_line_iterator (tria,
- tria->begin_raw_line(level)->level(),
- tria->begin_raw_line(level)->index(),
+ return raw_line_iterator (this->tria,
+ this->tria->begin_raw_line(level)->level(),
+ this->tria->begin_raw_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::begin_line (const unsigned int level) const {
- return line_iterator (tria,
- tria->begin_line(level)->level(),
- tria->begin_line(level)->index(),
+ return line_iterator (this->tria,
+ this->tria->begin_line(level)->level(),
+ this->tria->begin_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::begin_active_line (const unsigned int level) const {
- return active_line_iterator (tria,
- tria->begin_active_line(level)->level(),
- tria->begin_active_line(level)->index(),
+ return active_line_iterator (this->tria,
+ this->tria->begin_active_line(level)->level(),
+ this->tria->begin_active_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::begin_raw_quad (const unsigned int level) const {
- return raw_quad_iterator (tria,
- tria->begin_raw_quad(level)->level(),
- tria->begin_raw_quad(level)->index(),
+ return raw_quad_iterator (this->tria,
+ this->tria->begin_raw_quad(level)->level(),
+ this->tria->begin_raw_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::begin_quad (const unsigned int level) const {
- return quad_iterator (tria,
- tria->begin_quad(level)->level(),
- tria->begin_quad(level)->index(),
+ return quad_iterator (this->tria,
+ this->tria->begin_quad(level)->level(),
+ this->tria->begin_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::begin_active_quad (const unsigned int level) const {
- return active_quad_iterator (tria,
- tria->begin_active_quad(level)->level(),
- tria->begin_active_quad(level)->index(),
+ return active_quad_iterator (this->tria,
+ this->tria->begin_active_quad(level)->level(),
+ this->tria->begin_active_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::begin_raw_hex (const unsigned int level) const {
- return raw_hex_iterator (tria,
- tria->begin_raw_hex(level)->level(),
- tria->begin_raw_hex(level)->index(),
+ return raw_hex_iterator (this->tria,
+ this->tria->begin_raw_hex(level)->level(),
+ this->tria->begin_raw_hex(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::begin_hex (const unsigned int level) const {
- return hex_iterator (tria,
- tria->begin_hex(level)->level(),
- tria->begin_hex(level)->index(),
+ return hex_iterator (this->tria,
+ this->tria->begin_hex(level)->level(),
+ this->tria->begin_hex(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::begin_active_hex (const unsigned int level) const {
- return active_hex_iterator (tria,
- tria->begin_active_hex(level)->level(),
- tria->begin_active_hex(level)->index(),
+ return active_hex_iterator (this->tria,
+ this->tria->begin_active_hex(level)->level(),
+ this->tria->begin_active_hex(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::end_line () const {
- return raw_line_iterator (tria, -1, -1, this);
+ return raw_line_iterator (this->tria, -1, -1, this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::end_quad () const {
- return raw_quad_iterator (tria, -1, -1, this);
+ return raw_quad_iterator (this->tria, -1, -1, this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::end_hex () const {
- return raw_hex_iterator (tria, -1, -1, this);
+ return raw_hex_iterator (this->tria, -1, -1, this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_line_iterator
MGDoFHandler<dim>::last_raw_line (const unsigned int level) const {
- return raw_line_iterator (tria,
- tria->last_raw_line(level)->level(),
- tria->last_raw_line(level)->index(),
+ return raw_line_iterator (this->tria,
+ this->tria->last_raw_line(level)->level(),
+ this->tria->last_raw_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::line_iterator
MGDoFHandler<dim>::last_line (const unsigned int level) const {
- return line_iterator (tria,
- tria->last_line(level)->level(),
- tria->last_line(level)->index(),
+ return line_iterator (this->tria,
+ this->tria->last_line(level)->level(),
+ this->tria->last_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_line_iterator
MGDoFHandler<dim>::last_active_line (const unsigned int level) const {
- return active_line_iterator (tria,
- tria->last_active_line(level)->level(),
- tria->last_active_line(level)->index(),
+ return active_line_iterator (this->tria,
+ this->tria->last_active_line(level)->level(),
+ this->tria->last_active_line(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_quad_iterator
MGDoFHandler<dim>::last_raw_quad (const unsigned int level) const {
- return raw_quad_iterator (tria,
- tria->last_raw_quad(level)->level(),
- tria->last_raw_quad(level)->index(),
+ return raw_quad_iterator (this->tria,
+ this->tria->last_raw_quad(level)->level(),
+ this->tria->last_raw_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::quad_iterator
MGDoFHandler<dim>::last_quad (const unsigned int level) const {
- return quad_iterator (tria,
- tria->last_quad(level)->level(),
- tria->last_quad(level)->index(),
+ return quad_iterator (this->tria,
+ this->tria->last_quad(level)->level(),
+ this->tria->last_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_quad_iterator
MGDoFHandler<dim>::last_active_quad (const unsigned int level) const {
- return active_quad_iterator (tria,
- tria->last_active_quad(level)->level(),
- tria->last_active_quad(level)->index(),
+ return active_quad_iterator (this->tria,
+ this->tria->last_active_quad(level)->level(),
+ this->tria->last_active_quad(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::raw_hex_iterator
MGDoFHandler<dim>::last_raw_hex (const unsigned int level) const {
- return raw_hex_iterator (tria,
- tria->last_raw_hex(level)->level(),
- tria->last_raw_hex(level)->index(),
+ return raw_hex_iterator (this->tria,
+ this->tria->last_raw_hex(level)->level(),
+ this->tria->last_raw_hex(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::hex_iterator
MGDoFHandler<dim>::last_hex (const unsigned int level) const {
- return hex_iterator (tria,
- tria->last_hex(level)->level(),
- tria->last_hex(level)->index(),
+ return hex_iterator (this->tria,
+ this->tria->last_hex(level)->level(),
+ this->tria->last_hex(level)->index(),
this);
};
template <int dim>
typename MGDoFHandler<dim>::active_hex_iterator
MGDoFHandler<dim>::last_active_hex (const unsigned int level) const {
- return active_hex_iterator (tria,
- tria->last_active_hex(level)->level(),
- tria->last_active_hex(level)->index(),
+ return active_hex_iterator (this->tria,
+ this->tria->last_active_hex(level)->level(),
+ this->tria->last_active_hex(level)->index(),
this);
};
// reserve space for the MG dof numbers
reserve_space ();
- mg_used_dofs.resize (tria->n_levels(), 0);
+ mg_used_dofs.resize (this->tria->n_levels(), 0);
// clear user flags because we will
// need them
- tria->clear_user_flags ();
+ this->tria->clear_user_flags ();
// now distribute indices on each level
// separately
- for (unsigned int level=0; level<tria->n_levels(); ++level)
+ for (unsigned int level=0; level<this->tria->n_levels(); ++level)
{
unsigned int next_free_dof = offset;
cell_iterator cell = begin(level),
unsigned int
MGDoFHandler<2>::distribute_dofs_on_cell (cell_iterator &cell,
unsigned int next_free_dof) {
- if (selected_fe->dofs_per_vertex > 0)
+ if (this->selected_fe->dofs_per_vertex > 0)
// number dofs on vertices
for (unsigned int vertex=0; vertex<GeometryInfo<2>::vertices_per_cell; ++vertex)
// check whether dofs for this
// vertex have been distributed
// (only check the first dof)
if (cell->mg_vertex_dof_index(vertex, 0) == DoFHandler<2>::invalid_dof_index)
- for (unsigned int d=0; d<selected_fe->dofs_per_vertex; ++d)
+ for (unsigned int d=0; d<this->selected_fe->dofs_per_vertex; ++d)
cell->set_mg_vertex_dof_index (vertex, d, next_free_dof++);
// for the four sides
- if (selected_fe->dofs_per_line > 0)
+ if (this->selected_fe->dofs_per_line > 0)
for (unsigned int side=0; side<GeometryInfo<2>::faces_per_cell; ++side)
{
line_iterator line = cell->line(side);
// numbered (check only first dof)
if (line->mg_dof_index(0) == DoFHandler<2>::invalid_dof_index)
// if not: distribute dofs
- for (unsigned int d=0; d<selected_fe->dofs_per_line; ++d)
+ for (unsigned int d=0; d<this->selected_fe->dofs_per_line; ++d)
line->set_mg_dof_index (d, next_free_dof++);
};
// dofs of quad
- if (selected_fe->dofs_per_quad > 0)
+ if (this->selected_fe->dofs_per_quad > 0)
for (unsigned int d=0; d<selected_fe->dofs_per_quad; ++d)
cell->set_mg_dof_index (d, next_free_dof++);
// the present level
if ((i->get_coarsest_level() <= level) &&
(i->get_finest_level() >= level))
- for (unsigned int d=0; d<selected_fe->dofs_per_vertex; ++d)
- i->set_index (level, d, selected_fe->dofs_per_vertex,
+ for (unsigned int d=0; d<this->selected_fe->dofs_per_vertex; ++d)
+ i->set_index (level, d, this->selected_fe->dofs_per_vertex,
new_numbers[i->get_index (level, d,
- selected_fe->dofs_per_vertex)]);
+ this->selected_fe->dofs_per_vertex)]);
for (std::vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
i!=mg_levels[level]->line_dofs.end(); ++i)
void MGDoFHandler<2>::reserve_space () {
const unsigned int dim = 2;
- Assert (selected_fe != 0, DoFHandler<dim>::ExcNoFESelected());
- Assert (tria->n_levels() > 0, DoFHandler<2>::ExcInvalidTriangulation());
+ Assert (this->selected_fe != 0, DoFHandler<dim>::ExcNoFESelected());
+ Assert (this->tria->n_levels() > 0, DoFHandler<2>::ExcInvalidTriangulation());
////////////////////////////
// DESTRUCTION
// first allocate space for the
// lines and quads on each level
- for (unsigned int i=0; i<tria->n_levels(); ++i)
+ for (unsigned int i=0; i<this->tria->n_levels(); ++i)
{
mg_levels.push_back (new DoFLevel<2>);
- mg_levels.back()->line_dofs = std::vector<unsigned int> (tria->levels[i]->lines.lines.size() *
- selected_fe->dofs_per_line,
+ mg_levels.back()->line_dofs = std::vector<unsigned int> (this->tria->levels[i]->lines.lines.size() *
+ this->selected_fe->dofs_per_line,
DoFHandler<2>::invalid_dof_index);
- mg_levels.back()->quad_dofs = std::vector<unsigned int> (tria->levels[i]->quads.quads.size() *
- selected_fe->dofs_per_quad,
+ mg_levels.back()->quad_dofs = std::vector<unsigned int> (this->tria->levels[i]->quads.quads.size() *
+ this->selected_fe->dofs_per_quad,
DoFHandler<2>::invalid_dof_index);
};
// over all cells and storing the
// maximum and minimum level each
// vertex we pass by belongs to
- mg_vertex_dofs.resize (tria->vertices.size());
+ mg_vertex_dofs.resize (this->tria->vertices.size());
- std::vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
+ std::vector<unsigned int> min_level (this->tria->vertices.size(), tria->n_levels());
std::vector<unsigned int> max_level (tria->vertices.size(), 0);
Triangulation<dim>::cell_iterator cell = tria->begin(),
mg_vertex_dofs[vertex].init (min_level[vertex],
max_level[vertex],
- selected_fe->dofs_per_vertex);
+ this->selected_fe->dofs_per_vertex);
};
};
// we don't support anything else
// as well
static const MappingQ1<dim> mapping;
- FEValues<dim> fe_patch_values (mapping, dofs->get_fe(),
+ FEValues<dim> fe_patch_values (mapping, this->dofs->get_fe(),
patch_points, update_values);
const unsigned int n_q_points = patch_points.n_quadrature_points;
unsigned int cell_number = 0;
- typename std::vector<typename DataOutBase::Patch<dim> >::iterator patch = patches.begin();
+ typename std::vector<typename DataOutBase::Patch<dim> >::iterator patch = this->patches.begin();
typename DoFHandler<dim>::cell_iterator cell=first_cell();
// get first cell in this thread
- for (unsigned int i=0; (i<data.this_thread)&&(cell != dofs->end()); ++i)
+ for (unsigned int i=0; (i<data.this_thread)&&(cell != this->dofs->end()); ++i)
{
++patch;
++cell_number;
// now loop over all cells and
// actually create the patches
- for (;cell != dofs->end();)
+ for (;cell != this->dofs->end();)
{
- Assert (patch != patches.end(), ExcInternalError());
+ Assert (patch != this->patches.end(), ExcInternalError());
// Insert cell-patch pair into
// map for neighbors
fe_patch_values.reinit (cell);
// first fill dof_data
- for (unsigned int dataset=0; dataset<dof_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->dof_data.size(); ++dataset)
{
if (data.n_components == 1)
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values);
for (unsigned int q=0; q<n_q_points; ++q)
else
// system of components
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values_system);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values_system);
for (unsigned int component=0; component<data.n_components;
};
// then do the cell data
- for (unsigned int dataset=0; dataset<cell_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->cell_data.size(); ++dataset)
{
- if (cell_data[dataset].has_block)
+ if (this->cell_data[dataset].has_block)
{
- const double value = (*cell_data[dataset].block_data)(cell_number);
+ const double value = (*this->cell_data[dataset].block_data)(cell_number);
for (unsigned int q=0; q<n_q_points; ++q)
- patch->data(dataset+dof_data.size()*data.n_components,q) =
+ patch->data(dataset+this->dof_data.size()*data.n_components,q) =
value;
} else {
- const double value = (*cell_data[dataset].single_data)(cell_number);
+ const double value = (*this->cell_data[dataset].single_data)(cell_number);
for (unsigned int q=0; q<n_q_points; ++q)
- patch->data(dataset+dof_data.size()*data.n_components,q) =
+ patch->data(dataset+this->dof_data.size()*data.n_components,q) =
value;
}
};
};
// next cell (patch) in this thread
for (unsigned int i=0;
- (i<data.n_threads)&&(cell != dofs->end()); ++i)
+ (i<data.n_threads)&&(cell != this->dofs->end()); ++i)
{
++patch;
++cell_number;
ExcInvalidNumberOfSubdivisions(n_subdivisions));
typedef DataOut_DoFData<dim,dim> BaseClass;
- Assert (dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
+ Assert (this->dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
#ifdef DEAL_II_USE_MT
const unsigned int n_threads = n_threads_;
QIterated<dim> patch_points (q_trapez, n_subdivisions);
const unsigned int n_q_points = patch_points.n_quadrature_points;
- const unsigned int n_components = dofs->get_fe().n_components();
- const unsigned int n_datasets = dof_data.size() * n_components +
- cell_data.size();
+ const unsigned int n_components = this->dofs->get_fe().n_components();
+ const unsigned int n_datasets = this->dof_data.size() * n_components +
+ this->cell_data.size();
// clear the patches array
if (true)
{
typename std::vector<DataOutBase::Patch<dim> > dummy;
- patches.swap (dummy);
+ this->patches.swap (dummy);
};
// first count the cells we want to
// there is enough memory for that
unsigned int n_patches = 0;
for (typename DoFHandler<dim>::cell_iterator cell=first_cell();
- cell != dofs->end();
+ cell != this->dofs->end();
cell = next_cell(cell))
++n_patches;
DataOutBase::Patch<dim> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets, n_q_points);
- patches.insert (patches.end(), n_patches, default_patch);
+ this->patches.insert (patches.end(), n_patches, default_patch);
#ifdef DEAL_II_USE_MT
typename DoFHandler<dim>::cell_iterator
DataOut<dim>::first_cell ()
{
- return dofs->begin_active ();
+ return this->dofs->begin_active ();
};
// we don't support anything else
// as well
static const MappingQ1<dim> mapping;
- FEFaceValues<dim> fe_patch_values (mapping, dofs->get_fe(),
+ FEFaceValues<dim> fe_patch_values (mapping, this->dofs->get_fe(),
patch_points, update_values);
const unsigned int n_q_points = patch_points.n_quadrature_points;
unsigned int face_number = 0;
- typename std::vector<DataOutBase::Patch<dim-1,dim> >::iterator patch = patches.begin();
+ typename std::vector<DataOutBase::Patch<dim-1,dim> >::iterator patch = this->patches.begin();
FaceDescriptor face=first_face();
// get first face in this thread
- for (unsigned int i=0; (i<data.this_thread)&&(face.first != dofs->end()); ++i)
+ for (unsigned int i=0; (i<data.this_thread)&&(face.first != this->dofs->end()); ++i)
{
++patch;
++face_number;
// now loop over all cells and
// actually create the patches
- for (; face.first != dofs->end();)
+ for (; face.first != this->dofs->end();)
{
- Assert (patch != patches.end(), ExcInternalError());
+ Assert (patch != this->patches.end(), ExcInternalError());
for (unsigned int vertex=0; vertex<GeometryInfo<dim-1>::vertices_per_cell; ++vertex)
patch->vertices[vertex] = face.first->face(face.second)->vertex(vertex);
fe_patch_values.reinit (face.first, face.second);
// first fill dof_data
- for (unsigned int dataset=0; dataset<dof_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->dof_data.size(); ++dataset)
{
if (data.n_components == 1)
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values);
for (unsigned int q=0; q<n_q_points; ++q)
else
// system of components
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values_system);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values_system);
for (unsigned int component=0; component<data.n_components;
};
// then do the cell data
- for (unsigned int dataset=0; dataset<cell_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->cell_data.size(); ++dataset)
{
- if (cell_data[dataset].has_block)
+ if (this->cell_data[dataset].has_block)
{
- const double value = (*cell_data[dataset].block_data)(face_number);
+ const double value = (*this->cell_data[dataset].block_data)(face_number);
for (unsigned int q=0; q<n_q_points; ++q)
- patch->data(dataset+dof_data.size()*data.n_components,q) =
+ patch->data(dataset+this->dof_data.size()*data.n_components,q) =
value;
} else {
- const double value = (*cell_data[dataset].single_data)(face_number);
+ const double value = (*this->cell_data[dataset].single_data)(face_number);
for (unsigned int q=0; q<n_q_points; ++q)
- patch->data(dataset+dof_data.size()*data.n_components,q) =
+ patch->data(dataset+this->dof_data.size()*data.n_components,q) =
value;
}
};
};
// next cell (patch) in this thread
for (unsigned int i=0;
- (i<data.n_threads)&&(face.first != dofs->end()); ++i)
+ (i<data.n_threads)&&(face.first != this->dofs->end()); ++i)
{
++patch;
++face_number;
ExcInvalidNumberOfSubdivisions(n_subdivisions));
typedef DataOut_DoFData<dim,dim+1> BaseClass;
- Assert (dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
+ Assert (this->dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
#ifdef DEAL_II_USE_MT
const unsigned int n_threads = n_threads_;
QIterated<dim-1> patch_points (q_trapez, n_subdivisions);
const unsigned int n_q_points = patch_points.n_quadrature_points;
- const unsigned int n_components = dofs->get_fe().n_components();
- const unsigned int n_datasets = dof_data.size() * n_components +
- cell_data.size();
+ const unsigned int n_components = this->dofs->get_fe().n_components();
+ const unsigned int n_datasets = this->dof_data.size() * n_components +
+ this->cell_data.size();
// clear the patches array
if (true)
{
std::vector<DataOutBase::Patch<dim-1,dim> > dummy;
- patches.swap (dummy);
+ this->patches.swap (dummy);
};
// first count the cells we want to
// there is enough memory for that
unsigned int n_patches = 0;
for (FaceDescriptor face=first_face();
- face.first != dofs->end();
+ face.first != this->dofs->end();
face = next_face(face))
++n_patches;
DataOutBase::Patch<dim-1,dim> default_patch;
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets, n_q_points);
- patches.insert (patches.end(), n_patches, default_patch);
+ this->patches.insert (patches.end(), n_patches, default_patch);
#ifdef DEAL_II_USE_MT
{
// simply find first active cell
// with a face on the boundary
- typename DoFHandler<dim>::active_cell_iterator cell = dofs->begin_active();
- for (; cell != dofs->end(); ++cell)
+ typename DoFHandler<dim>::active_cell_iterator cell = this->dofs->begin_active();
+ for (; cell != this->dofs->end(); ++cell)
for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
if (cell->face(f)->at_boundary())
return FaceDescriptor(cell, f);
++active_cell;
// while there are active cells
- while (active_cell != dofs->end())
+ while (active_cell != this->dofs->end())
{
// check all the faces of this
// active cell
// we fell off the edge, so return
// with invalid pointer
- face.first = dofs->end();
+ face.first = this->dofs->end();
face.second = 0;
return face;
};
// we don't support anything else
// as well
static const MappingQ1<dim> mapping;
- FEValues<dim> fe_patch_values (mapping, dofs->get_fe(),
+ FEValues<dim> fe_patch_values (mapping, this->dofs->get_fe(),
patch_points, update_values);
const unsigned int n_patches_per_circle = data.n_patches_per_circle;
unsigned int cell_number = 0;
- typename std::vector<DataOutBase::Patch<dim+1> >::iterator patch = patches.begin();
+ typename std::vector<DataOutBase::Patch<dim+1> >::iterator patch = this->patches.begin();
typename DoFHandler<dim>::cell_iterator cell=first_cell();
// get first cell in this thread
- for (unsigned int i=0; (i<data.this_thread)&&(cell != dofs->end()); ++i)
+ for (unsigned int i=0; (i<data.this_thread)&&(cell != this->dofs->end()); ++i)
{
std::advance (patch, n_patches_per_circle);
++cell_number;
// now loop over all cells and
// actually create the patches
- for (; cell != dofs->end(); )
+ for (; cell != this->dofs->end(); )
{
for (unsigned int angle=0; angle<n_patches_per_circle; ++angle, ++patch)
{
- Assert (patch != patches.end(), ExcInternalError());
+ Assert (patch != this->patches.end(), ExcInternalError());
// first compute the
fe_patch_values.reinit (cell);
// first fill dof_data
- for (unsigned int dataset=0; dataset<dof_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->dof_data.size(); ++dataset)
{
if (data.n_components == 1)
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values);
switch (dim)
else
// system of components
{
- if (dof_data[dataset].has_block)
- fe_patch_values.get_function_values (*dof_data[dataset].block_data,
+ if (this->dof_data[dataset].has_block)
+ fe_patch_values.get_function_values (*this->dof_data[dataset].block_data,
data.patch_values_system);
else
- fe_patch_values.get_function_values (*dof_data[dataset].single_data,
+ fe_patch_values.get_function_values (*this->dof_data[dataset].single_data,
data.patch_values_system);
for (unsigned int component=0; component<data.n_components;
};
// then do the cell data
- for (unsigned int dataset=0; dataset<cell_data.size(); ++dataset)
+ for (unsigned int dataset=0; dataset<this->cell_data.size(); ++dataset)
{
- const double value = cell_data[dataset].has_block ?
- (*cell_data[dataset].block_data)(cell_number) :
+ const double value = this->cell_data[dataset].has_block ?
+ (*this->cell_data[dataset].block_data)(cell_number) :
(*cell_data[dataset].single_data)(cell_number);
switch (dim)
{
case 1:
for (unsigned int x=0; x<n_points; ++x)
for (unsigned int y=0; y<n_points; ++y)
- patch->data(dataset+dof_data.size()*data.n_components,
+ patch->data(dataset+this->dof_data.size()*data.n_components,
x*n_points +
y)
= value;
for (unsigned int x=0; x<n_points; ++x)
for (unsigned int y=0; y<n_points; ++y)
for (unsigned int z=0; z<n_points; ++z)
- patch->data(dataset+dof_data.size()*data.n_components,
+ patch->data(dataset+this->dof_data.size()*data.n_components,
x*n_points*n_points +
y*n_points +
z)
// threads, not the ones
// belonging to this thread.
const int skip_threads = static_cast<signed int>(data.n_threads)-1;
- for (int i=0; (i<skip_threads) && (cell != dofs->end()); ++i)
+ for (int i=0; (i<skip_threads) && (cell != this->dofs->end()); ++i)
std::advance (patch, n_patches_per_circle);
// however, cell and cell
// number have not yet been
// increased
- for (unsigned int i=0; (i<data.n_threads) && (cell != dofs->end()); ++i)
+ for (unsigned int i=0; (i<data.n_threads) && (cell != this->dofs->end()); ++i)
{
++cell_number;
cell=next_cell(cell);
ExcInvalidNumberOfSubdivisions(n_subdivisions));
typedef DataOut_DoFData<dim,dim+1> BaseClass;
- Assert (dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
+ Assert (this->dofs != 0, typename BaseClass::ExcNoDoFHandlerSelected());
#ifdef DEAL_II_USE_MT
const unsigned int n_threads = n_threads_;
QIterated<dim> patch_points (q_trapez, n_subdivisions);
const unsigned int n_q_points = patch_points.n_quadrature_points;
- const unsigned int n_components = dofs->get_fe().n_components();
- const unsigned int n_datasets = dof_data.size() * n_components +
- cell_data.size();
+ const unsigned int n_components = this->dofs->get_fe().n_components();
+ const unsigned int n_datasets = this->dof_data.size() * n_components +
+ this->cell_data.size();
// clear the patches array
if (true)
{
std::vector<DataOutBase::Patch<dim+1> > dummy;
- patches.swap (dummy);
+ this->patches.swap (dummy);
};
// first count the cells we want to
// there is enough memory for that
unsigned int n_patches = 0;
for (typename DoFHandler<dim>::cell_iterator cell=first_cell();
- cell != dofs->end();
+ cell != this->dofs->end();
cell = next_cell(cell))
++n_patches;
// then also take into account that
default_patch.n_subdivisions = n_subdivisions;
default_patch.data.reinit (n_datasets,
n_q_points * (n_subdivisions+1));
- patches.insert (patches.end(), n_patches, default_patch);
+ this->patches.insert (patches.end(), n_patches, default_patch);
#ifdef DEAL_II_USE_MT
typename DoFHandler<dim>::cell_iterator
DataOutRotation<dim>::first_cell ()
{
- return dofs->begin_active ();
+ return this->dofs->begin_active ();
};
// Memory allocation
Vr = this->memory.alloc();
- Vp = memory.alloc();
- Vz = memory.alloc();
- VAp = memory.alloc();
+ Vp = this->memory.alloc();
+ Vz = this->memory.alloc();
+ VAp = this->memory.alloc();
// define some aliases for simpler access
VECTOR& g = *Vr;
VECTOR& h = *Vp;
projects / dealii-svn.git / commitdiff