for (unsigned int d=0; d<dofs_per_line; ++d)
*next++ = this->line(line)->dof_index(d,fe_index);
for (unsigned int quad=0; quad<6; ++quad)
- for (unsigned int d=0; d<dofs_per_quad; ++d)
- *next++ = this->quad(quad)->dof_index(d,fe_index);
+ if (this->face_orientation(quad))
+ for (unsigned int d=0; d<dofs_per_quad; ++d)
+ *next++ = this->quad(quad)->dof_index(d,fe_index);
+ else
+ for (unsigned int d=0; d<dofs_per_quad; ++d)
+ *next++ = this->quad(quad)->dof_index(this->dof_handler->get_fe()[fe_index].
+ adjust_quad_dof_index_for_face_orientation(d),fe_index);
for (unsigned int d=0; d<dofs_per_hex; ++d)
*next++ = this->dof_index(d,fe_index);
}
std::pair<unsigned int, unsigned int>
face_system_to_component_index (const unsigned int index) const;
+ /**
+ * For faces with non-standard
+ * face_orientation in 3D, the dofs on
+ * faces (quads) have to be permuted in
+ * order to be combined with the correct
+ * shape functions. Given a local dof @p
+ * index on a quad, return the local index,
+ * if the face has non-standard
+ * face_orientation. In 2D and 1D there is
+ * no need for permutation so the identity
+ * is returned.
+ */
+ unsigned int adjust_quad_dof_index_for_face_orientation (const unsigned int index) const;
+
/**
* Return in which of the vector
* components of this finite
unsigned int
component_to_block_index (const unsigned int component) const;
- /**
- * For faces with non-standard
- * face_orientation in 3D, the shape
- * functions on faces have to be permutat
- * in order to be combined with the correct
- * dofs. This function returns a vector of
- * integer values, that have to be added to
- * the index of a shape function in order
- * to result in the permuted index. Prior
- * content of the vector @p shifts is
- * erased. In 3D a vector of length @p
- * dofs_per_quad is returned, in 2D and 1D
- * there is no need for permutation and a
- * vector of length 0 is returned, the same
- * is true for elements which have no dofs
- * on quads. The general implementation
- * returns a vector of zeros, resulting in
- * no permutation at all. This has to be
- * overloaded by derived finite element
- * classes.
- */
- virtual
- void
- get_face_shape_function_shifts (std::vector<int> &shifts) const;
-
//@}
/**
*/
std::vector<Point<dim-1> > generalized_face_support_points;
+ /**
+ * For faces with non-standard
+ * face_orientation in 3D, the dofs on
+ * faces (quads) have to be permuted in
+ * order to be combined with the correct
+ * shape functions. Given a local dof @p
+ * index on a quad, return the shift in the
+ * local index, if the face has
+ * non-standard face_orientation,
+ * i.e. <code>old_index + shift =
+ * new_index</code>. In 2D and 1D there is
+ * no need for permutation so the vector is
+ * empty. In 3D it has the size of @p
+ * dofs_per_quad.
+ *
+ * The standard implementation fills this
+ * with zeros, i.e. no permuatation at
+ * all. Derived finite element classes have
+ * to fill this vector with the correct
+ * values.
+ */
+ std::vector<int> adjust_quad_dof_index_for_face_orientation_table;
+
private:
/**
* Store what
virtual
FiniteElementDomination::Domination
compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
-
- /**
- * For faces with non-standard
- * face_orientation in 3D, the shape
- * functions on faces have to be permuted
- * in order to be combined with the correct
- * dofs. This function returns a vector of
- * integer values, that have to be added to
- * the index of a shape function in order
- * to result in the permuted index. Prior
- * content of the vector @p shifts is
- * erased. In 3D a vector of length @p
- * dofs_per_quad is returned, in 2D and 1D
- * there is no need for permutation and a
- * vector of length 0 is returned.
- */
- virtual
- void
- get_face_shape_function_shifts (std::vector<int> &shifts) const;
-
//@}
/**
* constructor.
*/
void initialize_unit_face_support_points ();
+
+ /**
+ * Initialize the
+ * @p adjust_quad_dof_index_for_face_orientation_table field
+ * of the FiniteElement
+ * class. Called from the
+ * constructor.
+ */
+ void initialize_quad_dof_index_permutation ();
/**
* Mapping from hierarchic to
virtual
FiniteElementDomination::Domination
compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
-
- /**
- * For faces with non-standard
- * face_orientation in 3D, the shape
- * functions on faces have to be permuted
- * in order to be combined with the correct
- * dofs. This function returns a vector of
- * integer values, that have to be added to
- * the index of a shape function in order
- * to result in the permuted index. Prior
- * content of the vector @p shifts is
- * erased. In 3D a vector of length @p
- * dofs_per_quad is returned, in 2D and 1D
- * there is no need for permutation and a
- * vector of length 0 is returned.
- */
- virtual
- void
- get_face_shape_function_shifts (std::vector<int> &shifts) const;
//@}
/**
*/
void initialize_unit_face_support_points ();
+ /**
+ * Initialize the
+ * @p adjust_quad_dof_index_for_face_orientation_table field
+ * of the FiniteElement
+ * class. Called from the
+ * constructor.
+ */
+ void initialize_quad_dof_index_permutation ();
+
/**
* Helper function used in the constructor:
* take a @p FiniteElementData object
* non-zero components.
*/
std::vector<unsigned int> shape_function_to_row_table;
-
- /**
- * Vector containing the permutation of
- * shape functions necessary if the faces
- * of a cell have the wrong
- * face_orientation. This is computed only
- * once. Actually, this does not contain
- * the permutation itself but rather the
- * shift of indices needed to calculate the
- * permutation.
- */
- std::vector<int> shift_in_face_shape_functions;
-
- /**
- * Vector containing the permutation of
- * shape functions due to faces with
- * non-standard face_orientation on a given
- * cell (recomputed on each cell.) If all
- * faces are oriented according to the
- * standard, this is the identity mapping.
- */
- std::vector<unsigned int> permuted_shape_functions;
-
- /**
- * Bool flag indicating the need to update
- * the @p permuted_shape_functions vector
- * on each cell. This is only necessary in
- * 3d and if the finite element has
- * shape_functions on the face.
- */
- bool update_shape_function_permutation;
-
+
/**
* Original update flags handed
* to the constructor of
const unsigned int point_no,
const unsigned int component) const;
- /**
- * If shape functions belong to a face in
- * 3D, they have to be permuted, if the
- * face has non-standard face
- * orientation. This functuion takes an
- * index of a shape function (on a standard
- * cell) and returns the corresponding
- * shape function on the real cell.
- */
- unsigned int
- shift_shape_function_index (const unsigned int i) const;
-
-
+
//@}
/// @name FunctionAccess Access to values of global finite element functions
//@{
*/
UpdateFlags compute_update_flags (const UpdateFlags update_flags) const;
- /**
- * Reinit the permutation of (face) shape
- * functions to match the present cell.
- */
- void reinit();
-
private:
/**
* Copy constructor. Since
FEValuesBase<dim>::shape_value (const unsigned int i,
const unsigned int j) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_values,
ExcAccessToUninitializedField());
- Assert (fe->is_primitive (I),
- ExcShapeFunctionNotPrimitive(I));
+ Assert (fe->is_primitive (i),
+ ExcShapeFunctionNotPrimitive(i));
// if the entire FE is primitive,
// then we can take a short-cut:
if (fe->is_primitive())
- return this->shape_values(I,j);
+ return this->shape_values(i,j);
else
// otherwise, use the mapping
// between shape function numbers
// question to which vector
// component the call of this
// function refers
- return this->shape_values(this->shape_function_to_row_table[I], j);
+ return this->shape_values(this->shape_function_to_row_table[i], j);
}
const unsigned int j,
const unsigned int component) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_values,
ExcAccessToUninitializedField());
Assert (component < fe->n_components(),
// system_to_component_table only
// works if the shape function is
// primitive):
- if (fe->is_primitive(I))
+ if (fe->is_primitive(i))
{
- if (component == fe->system_to_component_index(I).first)
- return this->shape_values(this->shape_function_to_row_table[I],j);
+ if (component == fe->system_to_component_index(i).first)
+ return this->shape_values(this->shape_function_to_row_table[i],j);
else
return 0;
}
// whether the shape function
// is non-zero at all within
// this component:
- if (fe->get_nonzero_components(I)[component] == false)
+ if (fe->get_nonzero_components(i)[component] == false)
return 0.;
// count how many non-zero
// shape function in the arrays
// we index presently:
const unsigned int
- row = (this->shape_function_to_row_table[I]
+ row = (this->shape_function_to_row_table[i]
+
- std::count (fe->get_nonzero_components(I).begin(),
- fe->get_nonzero_components(I).begin()+component,
+ std::count (fe->get_nonzero_components(i).begin(),
+ fe->get_nonzero_components(i).begin()+component,
true));
return this->shape_values(row, j);
};
FEValuesBase<dim>::shape_grad (const unsigned int i,
const unsigned int j) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_gradients,
ExcAccessToUninitializedField());
- Assert (fe->is_primitive (I),
- ExcShapeFunctionNotPrimitive(I));
+ Assert (fe->is_primitive (i),
+ ExcShapeFunctionNotPrimitive(i));
Assert (i<this->shape_gradients.size(),
- ExcIndexRange (I, 0, this->shape_gradients.size()));
+ ExcIndexRange (i, 0, this->shape_gradients.size()));
Assert (j<this->shape_gradients[0].size(),
ExcIndexRange (j, 0, this->shape_gradients[0].size()));
// if the entire FE is primitive,
// then we can take a short-cut:
if (fe->is_primitive())
- return this->shape_gradients[I][j];
+ return this->shape_gradients[i][j];
else
// otherwise, use the mapping
// between shape function numbers
// question to which vector
// component the call of this
// function refers
- return this->shape_gradients[this->shape_function_to_row_table[I]][j];
+ return this->shape_gradients[this->shape_function_to_row_table[i]][j];
}
const unsigned int j,
const unsigned int component) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_gradients,
ExcAccessToUninitializedField());
Assert (component < fe->n_components(),
// system_to_component_table only
// works if the shape function is
// primitive):
- if (fe->is_primitive(I))
+ if (fe->is_primitive(i))
{
- if (component == fe->system_to_component_index(I).first)
- return this->shape_gradients[this->shape_function_to_row_table[I]][j];
+ if (component == fe->system_to_component_index(i).first)
+ return this->shape_gradients[this->shape_function_to_row_table[i]][j];
else
return Tensor<1,dim>();
}
// whether the shape function
// is non-zero at all within
// this component:
- if (fe->get_nonzero_components(I)[component] == false)
+ if (fe->get_nonzero_components(i)[component] == false)
return Tensor<1,dim>();
// count how many non-zero
// shape function in the arrays
// we index presently:
const unsigned int
- row = (this->shape_function_to_row_table[I]
+ row = (this->shape_function_to_row_table[i]
+
- std::count (fe->get_nonzero_components(I).begin(),
- fe->get_nonzero_components(I).begin()+component,
+ std::count (fe->get_nonzero_components(i).begin(),
+ fe->get_nonzero_components(i).begin()+component,
true));
return this->shape_gradients[row][j];
};
FEValuesBase<dim>::shape_2nd_derivative (const unsigned int i,
const unsigned int j) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_second_derivatives,
ExcAccessToUninitializedField());
- Assert (fe->is_primitive (I),
+ Assert (fe->is_primitive (i),
ExcShapeFunctionNotPrimitive(i));
- Assert (I<this->shape_2nd_derivatives.size(),
- ExcIndexRange (I, 0, this->shape_2nd_derivatives.size()));
+ Assert (i<this->shape_2nd_derivatives.size(),
+ ExcIndexRange (i, 0, this->shape_2nd_derivatives.size()));
Assert (j<this->shape_2nd_derivatives[0].size(),
ExcIndexRange (j, 0, this->shape_2nd_derivatives[0].size()));
// if the entire FE is primitive,
// then we can take a short-cut:
if (fe->is_primitive())
- return this->shape_2nd_derivatives[I][j];
+ return this->shape_2nd_derivatives[i][j];
else
// otherwise, use the mapping
// between shape function numbers
// question to which vector
// component the call of this
// function refers
- return this->shape_2nd_derivatives[this->shape_function_to_row_table[I]][j];
+ return this->shape_2nd_derivatives[this->shape_function_to_row_table[i]][j];
}
const unsigned int j,
const unsigned int component) const
{
- const unsigned int I=shift_shape_function_index(i);
-
Assert (this->update_flags & update_second_derivatives,
ExcAccessToUninitializedField());
Assert (component < fe->n_components(),
// system_to_component_table only
// works if the shape function is
// primitive):
- if (fe->is_primitive(I))
+ if (fe->is_primitive(i))
{
- if (component == fe->system_to_component_index(I).first)
- return this->shape_2nd_derivatives[this->shape_function_to_row_table[I]][j];
+ if (component == fe->system_to_component_index(i).first)
+ return this->shape_2nd_derivatives[this->shape_function_to_row_table[i]][j];
else
return Tensor<2,dim>();
}
// shape function in the arrays
// we index presently:
const unsigned int
- row = (this->shape_function_to_row_table[I]
+ row = (this->shape_function_to_row_table[i]
+
- std::count (fe->get_nonzero_components(I).begin(),
- fe->get_nonzero_components(I).begin()+component,
+ std::count (fe->get_nonzero_components(i).begin(),
+ fe->get_nonzero_components(i).begin()+component,
true));
return this->shape_2nd_derivatives[row][j];
};
}
-
-template <int dim>
-inline
-unsigned int
-FEValuesBase<dim>::shift_shape_function_index (const unsigned int i) const
-{
- // standard implementation for 1D and 2D
- Assert(i<fe->dofs_per_cell, ExcInternalError());
- return i;
-}
-
-template <>
-inline
-unsigned int
-FEValuesBase<3>::shift_shape_function_index (const unsigned int i) const
-{
- Assert(i<fe->dofs_per_cell, ExcInternalError());
- return this->permuted_shape_functions[i];
-}
-
-
-
/*------------------------ Inline functions: FEValues ----------------------------*/
return this->boundary_forms[i];
}
-
-
#endif // DOXYGEN
DEAL_II_NAMESPACE_CLOSE
for (unsigned int d=0; d<dofs_per_line; ++d)
*next++ = this->line(line)->dof_index(d);
for (unsigned int quad=0; quad<6; ++quad)
- for (unsigned int d=0; d<dofs_per_quad; ++d)
- *next++ = this->quad(quad)->dof_index(d);
+ if (this->face_orientation(quad))
+ for (unsigned int d=0; d<dofs_per_quad; ++d)
+ *next++ = this->quad(quad)->dof_index(d);
+ else
+ for (unsigned int d=0; d<dofs_per_quad; ++d)
+ *next++ = this->quad(quad)->dof_index(this->dof_handler->get_fe().
+ adjust_quad_dof_index_for_face_orientation(d));
for (unsigned int d=0; d<dofs_per_hex; ++d)
*next++ = dof_index(d);
}
:
FiniteElementData<dim> (fe_data),
cached_primitivity(false),
+ adjust_quad_dof_index_for_face_orientation_table (this->dofs_per_quad, 0),
system_to_base_table(this->dofs_per_cell),
face_system_to_base_table(this->dofs_per_face),
component_to_base_table (this->components,
}
-#if deal_II_dimension < 3
-
template <int dim>
-void
-FiniteElement<dim>::get_face_shape_function_shifts (std::vector<int> &shifts) const
+unsigned int
+FiniteElement<dim>::adjust_quad_dof_index_for_face_orientation (const unsigned int) const
{
- // general template for 1D and 2D, return an
- // empty vector
- shifts.clear();
+ // general template for 1D and 2D: not implemented
+ Assert (false, ExcNotImplemented());
+ return deal_II_numbers::invalid_unsigned_int;
}
-#else
+#if deal_II_dimension == 3
template <>
-void
-FiniteElement<3>::get_face_shape_function_shifts (std::vector<int> &shifts) const
+unsigned int
+FiniteElement<3>::adjust_quad_dof_index_for_face_orientation (const unsigned int index) const
{
- shifts.clear();
- shifts.resize(this->dofs_per_quad,0);
+ Assert (index<this->dofs_per_quad, ExcIndexRange(index,0,this->dofs_per_quad));
+ Assert (adjust_quad_dof_index_for_face_orientation_table.size()==this->dofs_per_quad,
+ ExcInternalError());
+ return index+adjust_quad_dof_index_for_face_orientation_table[index];
}
#endif
initialize_constraints ();
initialize_embedding ();
initialize_restriction ();
+
+ initialize_quad_dof_index_permutation();
}
}
-
-template <int dim>
-void
-FE_Q<dim>::get_face_shape_function_shifts (std::vector<int> &shifts) const
-{
- // general template for 1D and 2D, return an
- // empty vector
- shifts.clear();
-}
-
-
-
-#if deal_II_dimension == 3
-
-template <>
-void
-FE_Q<3>::get_face_shape_function_shifts (std::vector<int> &shifts) const
-{
- shifts.resize(this->dofs_per_quad);
-
- unsigned int points=this->degree-1;
- Assert(points*points==this->dofs_per_quad, ExcInternalError());
-
- for (unsigned int local=0; local<this->dofs_per_quad; ++local)
- // face support points are in lexicographic
- // ordering with x running fastest. invert
- // that (y running fastest)
- shifts[local] = (local%points)*points + local/points - local;
-}
-
-#endif
-
//---------------------------------------------------------------------------
// Auxiliary functions
//---------------------------------------------------------------------------
+template <int dim>
+void
+FE_Q<dim>::initialize_quad_dof_index_permutation ()
+{
+ // general template for 1D and 2D, do nothing
+}
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+void
+FE_Q<3>::initialize_quad_dof_index_permutation ()
+{
+
+ Assert (adjust_quad_dof_index_for_face_orientation_table.size()==this->dofs_per_quad,
+ ExcInternalError());
+
+ unsigned int points=this->degree-1;
+ Assert(points*points==this->dofs_per_quad, ExcInternalError());
+
+ for (unsigned int local=0; local<this->dofs_per_quad; ++local)
+ // face support points are in lexicographic
+ // ordering with x running fastest. invert
+ // that (y running fastest)
+ this->adjust_quad_dof_index_for_face_orientation_table[local]
+ =(local%points)*points + local/points - local;
+}
+
+#endif
+
+
+
template <int dim>
std::vector<unsigned int>
FE_Q<dim>::get_dpo_vector(const unsigned int deg)
// on cell and face
initialize_unit_support_points ();
initialize_unit_face_support_points ();
+
+ initialize_quad_dof_index_permutation ();
}
+template <int dim>
+void
+FESystem<dim>::initialize_quad_dof_index_permutation ()
+{
+ // general template for 1D and 2D, do nothing
+}
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+void
+FESystem<3>::initialize_quad_dof_index_permutation ()
+{
+ // to obtain the shifts for this composed
+ // element, concatenate the shift vectors of
+ // the base elements
+ for (unsigned int b=0; b<n_base_elements();++b)
+ {
+ const std::vector<int> &temp=this->base_element(b).adjust_quad_dof_index_for_face_orientation_table;
+ for (unsigned int c=0; c<element_multiplicity(b); ++c)
+ adjust_quad_dof_index_for_face_orientation_table.insert
+ (adjust_quad_dof_index_for_face_orientation_table.begin(),
+ temp.begin(),temp.end());
+ }
+ Assert (adjust_quad_dof_index_for_face_orientation_table.size()==this->dofs_per_quad,
+ ExcInternalError());
+}
+
+#endif
+
+
+
template <int dim>
bool
FESystem<dim>::
-template <int dim>
-void
-FESystem<dim>::get_face_shape_function_shifts (std::vector<int> &shifts) const
-{
- // general template for 1D and 2D, return an
- // empty vector
- shifts.clear();
-}
-
-
-
-#if deal_II_dimension == 3
-
-template <>
-void
-FESystem<3>::get_face_shape_function_shifts (std::vector<int> &shifts) const
-{
- shifts.clear();
- std::vector<int> temp;
- // to obtain the shifts for this composed
- // element, concatenate the shift vectors of
- // the base elements
- for (unsigned int b=0; b<n_base_elements();++b)
- {
- this->base_element(b).get_face_shape_function_shifts(temp);
- for (unsigned int c=0; c<element_multiplicity(b); ++c)
- shifts.insert(shifts.begin(),temp.begin(),temp.end());
- }
- Assert (shifts.size()==this->dofs_per_quad, ExcInternalError());
-}
-
-#endif
-
-
-
template <int dim>
unsigned int
FESystem<dim>::memory_consumption () const
if (flags & update_cell_JxW_values)
this->cell_JxW_values.resize(n_quadrature_points);
-
- // initialize the permutation fields, if they
- // are needed
- if (dim==3)
- {
- permuted_shape_functions.resize(fe.dofs_per_cell);
- // initialize cell permutation mapping
- // with identity
- for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
- this->permuted_shape_functions[i]=i;
-
- if (fe.dofs_per_quad>0 &&
- (flags & update_values ||
- flags & update_gradients ||
- flags & update_second_derivatives))
- {
- // ask the fe to fill the vector of
- // shifts
- fe.get_face_shape_function_shifts(shift_in_face_shape_functions);
- Assert (shift_in_face_shape_functions.size()==fe.dofs_per_quad,
- ExcInternalError());
- update_shape_function_permutation=true;
- }
- else
- update_shape_function_permutation=false;
- }
- else
- update_shape_function_permutation=false;
}
}
-#if deal_II_dimension <3
-template <int dim>
-void FEValuesBase<dim>::reinit ()
-{
- // do nothing in 1D and 2D
-}
-#else
-
-template <>
-void FEValuesBase<3>::reinit ()
-{
- // in 3D reinit the permutation of face shape
- // functions, if necessary
- if (update_shape_function_permutation)
- {
- Assert (this->shift_in_face_shape_functions.size()==this->fe->dofs_per_quad,
- ExcInternalError());
- Triangulation<3>::cell_iterator thiscell = *(this->present_cell);
- unsigned int offset=fe->first_quad_index;
- for (unsigned int face_no=0; face_no<GeometryInfo<3>::faces_per_cell; ++face_no)
- {
- if (thiscell->face_orientation(face_no))
- for (unsigned int i=0; i<fe->dofs_per_quad; ++i)
- this->permuted_shape_functions[offset+i]=offset+i;
- else
- for (unsigned int i=0; i<fe->dofs_per_quad; ++i)
- this->permuted_shape_functions[offset+i]=offset+i+this->shift_in_face_shape_functions[i];
-
- offset+=this->fe->dofs_per_quad;
- }
- Assert (offset-fe->first_quad_index==GeometryInfo<3>::faces_per_cell*this->fe->dofs_per_quad,
- ExcInternalError());
- }
-}
-#endif
-
-
template <int dim>
template <class InputVector, typename number>
return (MemoryConsumption::memory_consumption (this->shape_values) +
MemoryConsumption::memory_consumption (this->shape_gradients) +
MemoryConsumption::memory_consumption (this->shape_2nd_derivatives) +
- MemoryConsumption::memory_consumption (this->permuted_shape_functions) +
- MemoryConsumption::memory_consumption (this->shift_in_face_shape_functions) +
MemoryConsumption::memory_consumption (this->JxW_values) +
MemoryConsumption::memory_consumption (this->quadrature_points) +
MemoryConsumption::memory_consumption (this->normal_vectors) +
MemoryConsumption::memory_consumption (this->boundary_forms) +
MemoryConsumption::memory_consumption (this->cell_JxW_values) +
sizeof(this->update_flags) +
- sizeof(this->update_shape_function_permutation) +
MemoryConsumption::memory_consumption (n_quadrature_points) +
MemoryConsumption::memory_consumption (dofs_per_cell) +
MemoryConsumption::memory_consumption (mapping) +
this->fe_data->clear_first_cell ();
this->mapping_data->clear_first_cell ();
-
- FEValuesBase<dim>::reinit();
}
this->fe_data->clear_first_cell ();
this->mapping_data->clear_first_cell ();
- FEValuesBase<dim>::reinit();
}
this->fe_data->clear_first_cell ();
this->mapping_data->clear_first_cell ();
- FEValuesBase<dim>::reinit();
}
<h3>deal.II</h3>
<ol>
- <li> <p> Fixed: On faces with wrong <code>face_orientation</code> the shape
- functions have to reordered in order to be combined with the correct
- dofs. This is only relevant for continuous elements in 3D. At least for
+ <li> <p> Fixed: On faces with wrong <code>face_orientation</code> the dofs
+ have to reordered in order to be combined with the correct shape
+ functions. This is only relevant for continuous elements in 3D. At least for
<code class="class">FE_Q</code> and systems of <code
class="class">FE_Q</code> this works now, for other finite elements the
reordering vector still has to be implemented.