QProjector< dim > Class Template Reference
[Quadrature formulas]

List of all members.

Classes

class  DataSetDescriptor

Public Types

typedef Quadrature< dim-1 > SubQuadrature

Static Public Member Functions

static void project_to_face (const SubQuadrature &quadrature, const unsigned int face_no, std::vector< Point< dim > > &q_points)
static Quadrature< dim > project_to_face (const SubQuadrature &quadrature, const unsigned int face_no)
static void project_to_subface (const SubQuadrature &quadrature, const unsigned int face_no, const unsigned int subface_no, std::vector< Point< dim > > &q_points, const RefinementCase< dim-1 > &ref_case=RefinementCase< dim-1 >::isotropic_refinement)
static Quadrature< dim > project_to_subface (const SubQuadrature &quadrature, const unsigned int face_no, const unsigned int subface_no, const RefinementCase< dim-1 > &ref_case=RefinementCase< dim-1 >::isotropic_refinement)
static Quadrature< dim > project_to_all_faces (const SubQuadrature &quadrature)
static Quadrature< dim > project_to_all_subfaces (const SubQuadrature &quadrature)
static Quadrature< dim > project_to_child (const Quadrature< dim > &quadrature, const unsigned int child_no)
static Quadrature< dim > project_to_line (const Quadrature< 1 > &quadrature, const Point< dim > &p1, const Point< dim > &p2)

Static Private Member Functions

static Quadrature< 2 > reflect (const Quadrature< 2 > &q)
static Quadrature< 2 > rotate (const Quadrature< 2 > &q, const unsigned int n_times)


Detailed Description

template<int dim>
class QProjector< dim >

This class is a helper class to facilitate the usage of quadrature formulae on faces or subfaces of cells. It computes the locations of quadrature points on the unit cell from a quadrature object for a manifold of one dimension less than that of the cell and the number of the face. For example, giving the Simpson rule in one dimension and using the project_to_face() function with face number 1, the returned points will be (1,0), (1,0.5) and (1,1). Note that faces have an orientation, so when projecting to face 3, you will get (0,0), (0,0.5) and (0,1), which is in clockwise sense, while for face 1 the points were in counterclockwise sense.

For the projection to subfaces (i.e. to the children of a face of the unit cell), the same applies as above. Note the order in which the children of a face are numbered, which in two dimensions coincides with the orientation of the face.

The second set of functions generates a quadrature formula by projecting a given quadrature rule on all faces and subfaces. This is used in the FEFaceValues and FESubfaceValues classes. Since we now have the quadrature points of all faces and subfaces in one array, we need to have a way to find the starting index of the points and weights corresponding to one face or subface within this array. This is done through the DataSetDescriptor member class.

The different functions are grouped into a common class to avoid putting them into global namespace. However, since they have no local data, all functions are declared static and can be called without creating an object of this class.

For the 3d case, you should note that the orientation of faces is even more intricate than for two dimensions. Quadrature formulae are projected upon the faces in their standard orientation, not to the inside or outside of the hexahedron. To make things more complicated, in 3d we allow faces in two orientations (which can be identified using cell->face_orientation(face)), so we have to project quadrature formula onto faces and subfaces in two orientations. (Refer to the documentation of the Triangulation class for a description of the orientation of the different faces, as well as to the glossary entry on face orientation for more information on this.) The DataSetDescriptor member class is used to identify where each dataset starts.

Author:
Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2003, 2005

Member Typedef Documentation

template<int dim>
typedef Quadrature<dim-1> QProjector< dim >::SubQuadrature

Define a typedef for a quadrature that acts on an object of one dimension less. For cells, this would then be a face quadrature.


Member Function Documentation

template<int dim>
static void QProjector< dim >::project_to_face ( const SubQuadrature quadrature,
const unsigned int  face_no,
std::vector< Point< dim > > &  q_points 
) [static]

Compute the quadrature points on the cell if the given quadrature formula is used on face face_no. For further details, see the general doc for this class.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_face ( const SubQuadrature quadrature,
const unsigned int  face_no 
) [static]

Compute the cell quadrature formula corresponding to using quadrature on face face_no. For further details, see the general doc for this class.

template<int dim>
static void QProjector< dim >::project_to_subface ( const SubQuadrature quadrature,
const unsigned int  face_no,
const unsigned int  subface_no,
std::vector< Point< dim > > &  q_points,
const RefinementCase< dim-1 > &  ref_case = RefinementCase< dim-1 >::isotropic_refinement 
) [static]

Compute the quadrature points on the cell if the given quadrature formula is used on face face_no, subface number subface_no corresponding to RefineCase::Type ref_case. The last argument is only used in 3D.

Note:
Only the points are transformed. The quadrature weights are the same as those of the original rule.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_subface ( const SubQuadrature quadrature,
const unsigned int  face_no,
const unsigned int  subface_no,
const RefinementCase< dim-1 > &  ref_case = RefinementCase< dim-1 >::isotropic_refinement 
) [static]

Compute the cell quadrature formula corresponding to using quadrature on subface subface_no of face face_no with RefinementCase<dim-1> ref_case. The last argument is only used in 3D.

Note:
Only the points are transformed. The quadrature weights are the same as those of the original rule.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_all_faces ( const SubQuadrature quadrature  )  [static]

Take a face quadrature formula and generate a cell quadrature formula from it where the quadrature points of the given argument are projected on all faces.

The weights of the new rule are replications of the original weights. This is not a proper handling, in that the sum of weights does not equal one, but it is consistent with the use of this function, namely to generate sets of face quadrature points on a cell, one set of which will then be selected at each time. This is used in the FEFaceValues class, where we initialize the values, derivatives, etc on all faces at once, while selecting the data of one particular face only happens later.

Note:
In 3D, this function produces eight sets of quadrature points for each face, in order to cope possibly different orientations of the mesh.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_all_subfaces ( const SubQuadrature quadrature  )  [static]

This function is alike the previous one, but projects the given face quadrature formula to the subfaces of a cell, i.e. to the children of the faces of the unit cell.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_child ( const Quadrature< dim > &  quadrature,
const unsigned int  child_no 
) [static]

Project a give quadrature formula to a child of a cell. You may want to use this function in case you want to extend an integral only over the area which a potential child would occupy. The child numbering is the same as the children would be numbered upon refinement of the cell.

As integration using this quadrature formula now only extends over a fraction of the cell, the weights of the resulting object are divided by GeometryInfo<dim>::children_per_cell.

template<int dim>
static Quadrature<dim> QProjector< dim >::project_to_line ( const Quadrature< 1 > &  quadrature,
const Point< dim > &  p1,
const Point< dim > &  p2 
) [static]

Project the onedimensional rule quadrature to the straight line connecting the points p1 and p2.

template<int dim>
static Quadrature<2> QProjector< dim >::reflect ( const Quadrature< 2 > &  q  )  [static, private]

Given a quadrature object in 2d, reflect all quadrature points at the main diagonal and return them with their original weights.

This function is necessary for projecting a 2d quadrature rule onto the faces of a 3d cube, since there we need both orientations.

template<int dim>
static Quadrature<2> QProjector< dim >::rotate ( const Quadrature< 2 > &  q,
const unsigned int  n_times 
) [static, private]

Given a quadrature object in 2d, rotate all quadrature points by n_times * 90 degrees counterclockwise and return them with their original weights.

This function is necessary for projecting a 2d quadrature rule onto the faces of a 3d cube, since there we need all rotations to account for face_flip and face_rotation of non-standard faces.


The documentation for this class was generated from the following file:

deal.II documentation generated on Sat Aug 15 16:52:16 2009 by doxygen 1.5.9