* elements.
*
* This function is more or less an
- * interface to the #FEValues# class and
- * should not be used by users unless
+ * interface to the #FEFaceValues# class
+ * and should not be used by users unless
* absolutely needed.
*/
virtual void fill_fe_face_values (const DoFHandler<dim>::cell_iterator &cell,
const bool compute_normal_vectors,
const Boundary<dim> &boundary) const;
+ /**
+ * This function does almost the same as
+ * the above one, with the difference that
+ * it considers the restriction of a finite
+ * element to a subface (the child of a
+ * face) rather than to a face. The number
+ * of the subface in the face is given by
+ * the #subface_no# parameter. The meaning
+ * of the other parameters is the same as
+ * for the #fill_fe_face_values# function.
+ *
+ * Since the usage of ansatz points on
+ * subfaces is not useful, it is excluded
+ * from the interface to this function.
+ *
+ * Like for the #fill_fe_face_values#
+ * function, there is a default
+ * implementation, using the
+ * #fill_fe_values# function. There may
+ * be better and more efficient solutions
+ * for a special finite element, which is
+ * why this function is made virtual.
+ *
+ * This function is more or less an
+ * interface to the #FESubfaceValues# class
+ * and should not be used by users unless
+ * absolutely needed.
+ */
virtual void fill_fe_subface_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
const vector<Point<dim-1> > &unit_points,
vector<double> &face_jacobi_determinants) const =0;
+ /**
+ * Does the same as the above function,
+ * except that it computes the Jacobi
+ * determinant of the transformation from
+ * the unit face to the subface of #face#
+ * with number #subface_no#.
+ *
+ * The function needs not take special care
+ * about boundary approximation, since it
+ * must not be called for faces at the
+ * boundary.
+ */
+ virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<double> &face_jacobi_determinants) const =0;
+
/**
* Compute the normal vectors to the cell
* at the quadrature points. See the
const Boundary<dim> &boundary,
const vector<Point<dim-1> > &unit_points,
vector<Point<dim> > &normal_vectors) const =0;
-
+
+ /**
+ * Does the same as the above function,
+ * except that it refers to the
+ * subface #subface_no# of the given face.
+ *
+ * The function needs not take special care
+ * about boundary approximation, since it
+ * must not be called for faces at the
+ * boundary.
+ */
+ virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
+ const unsigned int face_no,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<Point<dim> > &normal_vectors) const =0;
+
/**
* Exception
*/
* Exception
*/
DeclException0 (ExcNotImplemented);
+ /**
+ * Exception
+ */
+ DeclException0 (ExcBoundaryFaceUsed);
};
/**
* Refer to the base class for detailed
* information on this function.
+ *
+ * In two spatial dimensions, this function
+ * simply returns the length of the face.
*/
virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
const Boundary<dim> &boundary,
vector<double> &face_jacobi_determinants) const;
/**
+ * Refer to the base class for detailed
+ * information on this function.
+ *
+ * In two spatial dimensions, this function
+ * simply returns half the length of the
+ * whole face.
+ */
+ virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<double> &face_jacobi_determinants) const;
+
+ /**
+ * Return the normal vectors to the
+ * face with number #face_no# of #cell#.
+ *
* For linear finite elements, this function
* is particularly simple since all normal
* vectors are equal and can easiliy be
const Boundary<dim> &boundary,
const vector<Point<dim-1> > &unit_points,
vector<Point<dim> > &normal_vectors) const;
+
+ /**
+ * Return the normal vectors to the
+ * subface with number #subface_no# of
+ * the face with number #face_no# of #cell#.
+ *
+ * For linear finite elements, this function
+ * is particularly simple since all normal
+ * vectors are equal and can easiliy be
+ * computed from the direction of the face
+ * without using the transformation (Jacobi)
+ * matrix, at least for two dimensions.
+ *
+ * Refer to the base class for detailed
+ * information on this function.
+ */
+ virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
+ const unsigned int face_no,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<Point<dim> > &normal_vectors) const;
};
const vector<Point<dim-1> > &unit_points,
vector<double> &face_jacobi_determinants) const;
+ /**
+ * Refer to the base class for detailed
+ * information on this function.
+ */
+ virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<double> &face_jacobi_determinants) const;
+
/**
* Refer to the base class for detailed
* information on this function.
const Boundary<dim> &boundary,
const vector<Point<dim-1> > &unit_points,
vector<Point<dim> > &normal_vectors) const;
+
+ /**
+ * Refer to the base class for detailed
+ * information on this function.
+ */
+ virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
+ const unsigned int subface_no,
+ const unsigned int face_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<Point<dim> > &normal_vectors) const;
};
const vector<Point<dim-1> > &unit_points,
vector<double> &face_jacobi_determinants) const;
+ /**
+ * Refer to the base class for detailed
+ * information on this function.
+ */
+ virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
+ const unsigned int subface_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<double> &face_jacobi_determinants) const;
+
/**
* Refer to the base class for detailed
* information on this function.
const Boundary<dim> &boundary,
const vector<Point<dim-1> > &unit_points,
vector<Point<dim> > &normal_vectors) const;
+
+ /**
+ * Refer to the base class for detailed
+ * information on this function.
+ */
+ virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
+ const unsigned int subface_no,
+ const unsigned int face_no,
+ const vector<Point<dim-1> > &unit_points,
+ vector<Point<dim> > &normal_vectors) const;
};
* Compute the points on the real cell
* on which the ansatz functions are
* located.
+ *
+ * Giving this flag to the
+ * #FESubfaceValues# class will result
+ * in an error, since ansatz points are
+ * not useful in that case.
*/
update_ansatz_points = 16,
/**
* to the face relative to this cell.
* This flag is only evaluated by
* the #FEFaceValues# class.
+ *
+ * Giving this flag to the
+ * #FEValues# class will result in
+ * an error, since normal vectors are
+ * not useful in that case.
*/
update_normal_vectors = 32
};
quadrature points on the unit cell, which are stored in the
#unit_quadrature_points# array. Note that #1<<(dim-1)# is the number of
subfaces per face.
+
+ One subtle problem is that if a face is at the boundary, then computation
+ of subfaces may be a bit tricky, since we do not know whether the user
+ intends to better approximate the boundary by the subfaces or only wants
+ to have the subfaces be one part of the mother face. However, it is hardly
+ conceivable what someone wants when using this class for faces at the
+ boundary, in the end this class was invented to facilitate integration
+ along faces with cells of different refinement levels on both sides,
+ integration along the boundary of the domain is better done through
+ the #FEFaceValues# class. For this reason, calling #reinit# with a
+ boundary face will result in an error.
@author Wolfgang Bangerth, 1998
*/
const unsigned int subface_no,
const FiniteElement<dim> &fe,
const Boundary<dim> &boundary);
+
+ /**
+ * Exception
+ */
+ DeclException0 (ExcReinitCalledWithBoundaryFace);
};