for (unsigned int i=0; i<dim; ++i)
{
q1=p-ht[i];
- grad[i]=(value(p, comp)-value(q1, comp))/h;
+ grad[i]=(this->value(p, comp)-this->value(q1, comp))/h;
}
break;
}
{
q1=p+ht[i];
q2=p-ht[i];
- grad[i]=(value(q1, comp)-value(q2, comp))/(2*h);
+ grad[i]=(this->value(q1, comp)-this->value(q2, comp))/(2*h);
}
break;
}
q1=q2+ht[i];
q3=p-ht[i];
q4=q3-ht[i];
- grad[i]=(- value(q1, comp)
- +8*value(q2, comp)
- -8*value(q3, comp)
- + value(q4, comp))/(12*h);
+ grad[i]=(- this->value(q1, comp)
+ +8*this->value(q2, comp)
+ -8*this->value(q3, comp)
+ + this->value(q4, comp))/(12*h);
}
break;
for (unsigned int i=0; i<dim; ++i)
{
q1=p-ht[i];
- vector_value(p, v);
- vector_value(q1, v1);
+ this->vector_value(p, v);
+ this->vector_value(q1, v1);
for (unsigned int comp=0; comp<this->n_components; ++comp)
gradients[comp][i]=(v(comp)-v1(comp))*h_inv;
{
q1=p+ht[i];
q2=p-ht[i];
- vector_value(q1, v1);
- vector_value(q2, v2);
+ this->vector_value(q1, v1);
+ this->vector_value(q2, v2);
for (unsigned int comp=0; comp<this->n_components; ++comp)
gradients[comp][i]=(v1(comp)-v2(comp))*h_inv_2;
q1=q2+ht[i];
q3=p-ht[i];
q4=q3-ht[i];
- vector_value(q1, v1);
- vector_value(q2, v2);
- vector_value(q3, v3);
- vector_value(q4, v4);
+ this->vector_value(q1, v1);
+ this->vector_value(q2, v2);
+ this->vector_value(q3, v3);
+ this->vector_value(q4, v4);
for (unsigned int comp=0; comp<this->n_components; ++comp)
gradients[comp][i]=(-v1(comp)+8*v2(comp)-8*v3(comp)+v4(comp))*h_inv_12;
for (unsigned int i=0; i<dim; ++i)
{
q1=points[p]-ht[i];
- gradients[p][i]=(value(points[p], comp)-value(q1, comp))/h;
+ gradients[p][i]=(this->value(points[p], comp)-this->value(q1, comp))/h;
}
break;
}
{
q1=points[p]+ht[i];
q2=points[p]-ht[i];
- gradients[p][i]=(value(q1, comp)-value(q2, comp))/(2*h);
+ gradients[p][i]=(this->value(q1, comp)-this->value(q2, comp))/(2*h);
}
break;
}
q1=q2+ht[i];
q3=points[p]-ht[i];
q4=q3-ht[i];
- gradients[p][i]=(- value(q1, comp)
- +8*value(q2, comp)
- -8*value(q3, comp)
- + value(q4, comp))/(12*h);
+ gradients[p][i]=(- this->value(q1, comp)
+ +8*this->value(q2, comp)
+ -8*this->value(q3, comp)
+ + this->value(q4, comp))/(12*h);
}
break;
}
{
q1=points[p]-ht[i];
for (unsigned int comp=0; comp<this->n_components; ++comp)
- gradients[p][comp][i]=(value(points[p], comp)-value(q1, comp))/h;
+ gradients[p][comp][i]=(this->value(points[p], comp)-this->value(q1, comp))/h;
}
break;
}
q1=points[p]+ht[i];
q2=points[p]-ht[i];
for (unsigned int comp=0; comp<this->n_components; ++comp)
- gradients[p][comp][i]=(value(q1, comp)-value(q2, comp))/(2*h);
+ gradients[p][comp][i]=(this->value(q1, comp)-this->value(q2, comp))/(2*h);
}
break;
}
q3=points[p]-ht[i];
q4=q3-ht[i];
for (unsigned int comp=0; comp<this->n_components; ++comp)
- gradients[p][comp][i]=(- value(q1, comp)
- +8*value(q2, comp)
- -8*value(q3, comp)
- + value(q4, comp))/(12*h);
+ gradients[p][comp][i]=(- this->value(q1, comp)
+ +8*this->value(q2, comp)
+ -8*this->value(q3, comp)
+ + this->value(q4, comp))/(12*h);
}
break;
}
* not already initialized.
*/
template <int dim_> friend class FESystem;
+
+ /**
+ * Make the inner class a
+ * friend. This is not strictly
+ * necessary, but the Intel
+ * compiler seems to want this.
+ */
+ friend class InternalDataBase;
};
for(unsigned i=0; i<this->get_steps(); ++i)
{
(*matrix)[level].residual(h1, u, rhs);
- set_zero_interior_boundary(level,h1);
+ this->set_zero_interior_boundary(level,h1);
((*matrix)[level].*relaxation)(h2,h1,omega);
- set_zero_interior_boundary(level,h2);
+ this->set_zero_interior_boundary(level,h2);
u.add(h2);
}
}
if (!this->has_children())
// if this cell has no children: simply
// return the exact values on this cell
- get_dof_values (values, interpolated_values);
+ this->get_dof_values (values, interpolated_values);
else
// otherwise clobber them from the children
{
if (!this->has_children())
// if this cell has no children: simply
// set the values on this cell
- set_dof_values (local_values, values);
+ this->set_dof_values (local_values, values);
else
// otherwise distribute them to the children
{
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
};
std::vector<Tensor<1,dim> > shape_values (n_q_points);
- Assert (data.shape_values.n_rows() == dofs_per_cell * dim,
+ Assert (data.shape_values.n_rows() == this->dofs_per_cell * dim,
ExcInternalError());
Assert (data.shape_values.n_cols() == n_q_points,
ExcInternalError());
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
};
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, 0, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
if (flags & update_second_derivatives)
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
? face_no * n_q_points
:(face_no * GeometryInfo<dim>::subfaces_per_face
+ sub_no) * n_q_points;
- compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
+ this->compute_2nd (mapping, cell, offset, mapping_data, fe_data, data);
}
}
const Quadrature<dim> &quadrature) const
{
InternalData *data = new InternalData(n_shape_functions);
- compute_data (update_flags, quadrature,
- quadrature.n_quadrature_points, *data);
+ this->compute_data (update_flags, quadrature,
+ quadrature.n_quadrature_points, *data);
if (!use_mapping_q_on_all_cells)
- compute_data (update_flags, quadrature,
- quadrature.n_quadrature_points, data->mapping_q1_data);
+ this->compute_data (update_flags, quadrature,
+ quadrature.n_quadrature_points, data->mapping_q1_data);
return data;
}
{
InternalData *data = new InternalData(n_shape_functions);
Quadrature<dim> q (QProjector<dim>::project_to_all_faces(quadrature));
- compute_face_data (update_flags, q,
- quadrature.n_quadrature_points, *data);
+ this->compute_face_data (update_flags, q,
+ quadrature.n_quadrature_points, *data);
if (!use_mapping_q_on_all_cells)
- compute_face_data (update_flags, q,
- quadrature.n_quadrature_points,
- data->mapping_q1_data);
+ this->compute_face_data (update_flags, q,
+ quadrature.n_quadrature_points,
+ data->mapping_q1_data);
return data;
}
{
InternalData *data = new InternalData(n_shape_functions);
Quadrature<dim> q (QProjector<dim>::project_to_all_subfaces(quadrature));
- compute_face_data (update_flags, q,
- quadrature.n_quadrature_points, *data);
+ this->compute_face_data (update_flags, q,
+ quadrature.n_quadrature_points, *data);
if (!use_mapping_q_on_all_cells)
- compute_face_data (update_flags, q,
- quadrature.n_quadrature_points,
- data->mapping_q1_data);
+ this->compute_face_data (update_flags, q,
+ quadrature.n_quadrature_points,
+ data->mapping_q1_data);
return data;
}
else
p_data=&data;
- compute_fill_face (cell, face_no, false,
- npts, offset, q.get_weights(),
- *p_data,
- quadrature_points, JxW_values,
- exterior_forms, normal_vectors);
+ this->compute_fill_face (cell, face_no, false,
+ npts, offset, q.get_weights(),
+ *p_data,
+ quadrature_points, JxW_values,
+ exterior_forms, normal_vectors);
}
else
p_data=&data;
- compute_fill_face (cell, face_no, true,
- npts, offset, q.get_weights(),
- *p_data,
- quadrature_points, JxW_values,
- exterior_forms, normal_vectors);
+ this->compute_fill_face (cell, face_no, true,
+ npts, offset, q.get_weights(),
+ *p_data,
+ quadrature_points, JxW_values,
+ exterior_forms, normal_vectors);
}
InternalData quadrature_data(n_shape_functions);
quadrature_data.shape_derivatives.resize(n_shape_functions * n_q_points);
- compute_shapes(quadrature.get_points(), quadrature_data);
+ this->compute_shapes(quadrature.get_points(), quadrature_data);
// Compute the stiffness matrix of
// the inner dofs
compute_mapping_support_points(cell, p_data->mapping_support_points);
- const Point<dim> q=transform_unit_to_real_cell_internal(*p_data);
+ const Point<dim> q=this->transform_unit_to_real_cell_internal(*p_data);
delete mdata;
return q;
}
std::vector<Point<dim> > &points=mdata->mapping_support_points;
compute_mapping_support_points(cell, points);
- transform_real_to_unit_cell_internal(cell, p, *mdata, p_unit);
+ this->transform_real_to_unit_cell_internal(cell, p, *mdata, p_unit);
delete mdata;
}
// defined by the order of vertices
// in the cell object
Face new_faces[GeometryInfo<dim>::faces_per_cell]
- = { { { vertices[0], vertices[1] } },
- { { vertices[1], vertices[2] } },
- { { vertices[3], vertices[2] } },
- { { vertices[0], vertices[3] } } };
+ = { { { this->vertices[0], this->vertices[1] } },
+ { { this->vertices[1], this->vertices[2] } },
+ { { this->vertices[3], this->vertices[2] } },
+ { { this->vertices[0], this->vertices[3] } } };
// then insert them into the global
// list and store iterators to
// reversed here compared to the
// Cell class, for simplicity
const Face new_faces_tmp[GeometryInfo<dim>::faces_per_cell]
- = { { { vertices[0], vertices[1], vertices[2], vertices[3] } },
- { { vertices[4], vertices[5], vertices[6], vertices[7] } },
- { { vertices[0], vertices[1], vertices[5], vertices[4] } },
- { { vertices[1], vertices[5], vertices[6], vertices[2] } },
- { { vertices[3], vertices[2], vertices[6], vertices[7] } },
- { { vertices[0], vertices[4], vertices[7], vertices[3] } } };
+ = { { { this->vertices[0], this->vertices[1],
+ this->vertices[2], this->vertices[3] } },
+ { { this->vertices[4], this->vertices[5],
+ this->vertices[6], this->vertices[7] } },
+ { { this->vertices[0], this->vertices[1],
+ this->vertices[5], this->vertices[4] } },
+ { { this->vertices[1], this->vertices[5],
+ this->vertices[6], this->vertices[2] } },
+ { { this->vertices[3], this->vertices[2],
+ this->vertices[6], this->vertices[7] } },
+ { { this->vertices[0], this->vertices[4],
+ this->vertices[7], this->vertices[3] } } };
Face new_faces[GeometryInfo<dim>::faces_per_cell][GridReorderingInfo<dim>::rotational_states_of_faces]
= { { new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[1], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[1], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
{ new_faces_tmp[2], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[3], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[4], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[5], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] }};
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[3], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[4], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[5], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] }};
// first do the faces in their
// usual direction
// cell we are working on
CellData<dim> standard_cell;
for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
- standard_cell.vertices[v] = vertices[v];
+ standard_cell.vertices[v] = this->vertices[v];
// then rotate it the given
// number of times
MGDoFObjectAccessor<1, dim>::copy_from (const MGDoFObjectAccessor<1, dim> &a)
{
DoFObjectAccessor<1, dim>::copy_from (a);
- set_mg_dof_handler (a.mg_dof_handler);
+ this->set_mg_dof_handler (a.mg_dof_handler);
};
MGDoFObjectAccessor<2, dim>::copy_from (const MGDoFObjectAccessor<2, dim> &a)
{
DoFObjectAccessor<2, dim>::copy_from (a);
- set_mg_dof_handler (a.mg_dof_handler);
+ this->set_mg_dof_handler (a.mg_dof_handler);
};
void
MGDoFObjectAccessor<3, dim>::copy_from (const MGDoFObjectAccessor<3, dim> &a) {
DoFObjectAccessor<3, dim>::copy_from (a);
- set_mg_dof_handler (a.mg_dof_handler);
+ this->set_mg_dof_handler (a.mg_dof_handler);
};
MGDoFCellAccessor<3>::face_iterator
MGDoFCellAccessor<3>::face (const unsigned int i) const
{
- return quad(i);
+ return this->quad(i);
};
#endif
if (old_cell->has_children() && new_cell->has_children())
for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
- mirror_refinement_flags<dim> (new_cell->child(c), old_cell->child(c));
+ ::mirror_refinement_flags<dim> (new_cell->child(c), old_cell->child(c));
};
template <int dim>
static bool
-adapt_grids (const typename Triangulation<dim>::cell_iterator &cell1,
- const typename Triangulation<dim>::cell_iterator &cell2)
+adapt_grid_cells (const typename Triangulation<dim>::cell_iterator &cell1,
+ const typename Triangulation<dim>::cell_iterator &cell2)
{
if (cell2->has_children() && cell1->has_children())
bool grids_changed = false;
for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
- grids_changed |= adapt_grids<dim> (cell1->child(c), cell2->child(c));
+ grids_changed |= ::adapt_grid_cells<dim> (cell1->child(c),
+ cell2->child(c));
return grids_changed;
};
typename Triangulation<dim>::cell_iterator(tria1.end()) :
tria1.begin(1));
for (; cell1!=endc; ++cell1, ++cell2)
- grids_changed |= adapt_grids<dim> (cell1, cell2);
+ grids_changed |= ::adapt_grid_cells<dim> (cell1, cell2);
return grids_changed;
};
// (there are more coming below then
// also)
if (refinement_flags.adapt_grids)
- adapt_grids<dim> (*previous_tria, *tria);
+ ::adapt_grids<dim> (*previous_tria, *tria);
// perform flagging of cells
// needed to regularize the
// strange things may happen
if (refinement_flags.mirror_flags_to_previous_grid)
{
- adapt_grids<dim> (*previous_tria, *tria);
+ ::adapt_grids<dim> (*previous_tria, *tria);
typename Triangulation<dim>::cell_iterator old_cell, new_cell, endc;
old_cell = previous_tria->begin(0);
new_cell = tria->begin(0);
endc = tria->end(0);
for (; new_cell!=endc; ++new_cell, ++old_cell)
- mirror_refinement_flags<dim> (new_cell, old_cell);
+ ::mirror_refinement_flags<dim> (new_cell, old_cell);
};
tria->prepare_coarsening_and_refinement ();
// cells to avoid the previous grid
// to have cells refined twice more
// than the present one and vica versa.
- adapt_grids<dim> (*previous_tria, *tria);
+ ::adapt_grids<dim> (*previous_tria, *tria);
};
};