const Quadrature<dim> &quadrature);
/**
- * Storage for @p FEValues
+ * Storage for FEValues
* objects needed to
* approximate second
* derivatives.
*
- * The ordering is <tt>p+hx</tt>,
- * <tt>p+hy</tt>, <tt>p+hz</tt>,
- * @p p-hx, @p p-hy,
- * @p p-hz, where unused
+ * The ordering is <i>p+hx</i>,
+ * <i>p+hy</i>, <i>p+hz</i>,
+ * <i>p-hx</i>, <i>p-hy</i>,
+ * <i>p-hz</i>, where unused
* entries in lower dimensions
* are missing.
*/
* classes implementing this
* function should throw an
* exception of type
- * @p ExcShapeFunctionNotPrimitive. In
+ * ExcShapeFunctionNotPrimitive. In
* that case, use the
* shape_value_component()
* function.
*
* An
- * @p ExcUnitShapeValuesDoNotExist
+ * ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p FiniteElement under
+ * of the FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p shape_value,
+ * Just like for shape_value(),
* but this function will be
* called when the shape function
* has more than one non-zero
* classes implementing this
* function should throw an
* exception of type
- * @p ExcShapeFunctionNotPrimitive. In
+ * ExcShapeFunctionNotPrimitive. In
* that case, use the
* shape_grad_component()
* function.
*
* An
- * @p ExcUnitShapeValuesDoNotExist
+ * ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p FiniteElement under
+ * of the FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p shape_grad,
+ * Just like for shape_grad(),
* but this function will be
* called when the shape function
* has more than one non-zero
* classes implementing this
* function should throw an
* exception of type
- * @p ExcShapeFunctionNotPrimitive. In
+ * ExcShapeFunctionNotPrimitive. In
* that case, use the
* shape_grad_grad_component()
* function.
*
* An
- * @p ExcUnitShapeValuesDoNotExist
+ * ExcUnitShapeValuesDoNotExist
* is thrown if the shape values
- * of the @p FiniteElement under
+ * of the FiniteElement under
* consideration depends on the
* shape of the cell in real
* space.
const Point<dim> &p) const;
/**
- * Just like for @p shape_grad_grad,
+ * Just like for shape_grad_grad(),
* but this function will be
* called when the shape function
* has more than one non-zero
* concatenation or the sum of
* the cell matrices @p P_i,
* depending on the
- * @p restriction_is_additive_flags
- * given to the constructor. This
+ * #restriction_is_additive_flags. This
* distinguishes interpolation
* (concatenation) and projection
* with respect to scalar
* implemented in the derived
* finite element class, this
* function aborts with
- * @p ExcProjectionVoid.
+ * ExcProjectionVoid.
*/
const FullMatrix<double> &
get_restriction_matrix (const unsigned int child) const;
* implemented in the derived
* finite element class, this
* function aborts with
- * @p ExcEmbeddingVoid. You can
+ * ExcEmbeddingVoid. You can
* check whether this is the case
* by calling the
* prolongation_is_implemented().
* Return whether this element implements
* its prolongation matrices. The return
* value also indicates whether a call to
- * the @p get_prolongation_matrix
+ * the get_prolongation_matrix()
* function will generate an error or
* not.
*
* Return whether this element implements
* its restriction matrices. The return
* value also indicates whether a call to
- * the @p get_restriction_matrix
+ * the get_restriction_matrix()
* function will generate an error or
* not.
*
/**
* Access the
- * @p restriction_is_additive_flag
+ * #restriction_is_additive_flags
* field. See there for more
* information on its contents.
*
* should have a way to live with
* this, then you might want to
* use the
- * @p constraints_are_implemented
+ * constraints_are_implemented()
* function to check up front
* whethehr this function will
* succeed or generate the
* implements its hanging node
* constraints. The return value
* also indicates whether a call
- * to the @p constraint function
+ * to the constraints() function
* will generate an error or not.
*
* This function is mostly here
* and get_subface_interpolation_matrix
* methods. Therefore the return
* value also indicates whether a call
- * to the @p get_face_interpolation_matrix
- * method and the @p get_subface_interpolation_matrix
+ * to the get_face_interpolation_matrix()
+ * method and the get_subface_interpolation_matrix()
* method will generate an error or not.
*
* Currently the main purpose of this
* interpolating from the given
* finite element to the present
* one. The size of the matrix is
- * then @p dofs_per_cell times
- * <tt>source.dofs_per_cell</tt>.
+ * then #dofs_per_cell times
+ * <tt>source.#dofs_per_cell</tt>.
*
* Derived elements will have to
* implement this function. They
* of one element to the face of
* the neighboring element.
* The size of the matrix is
- * then <tt>source.dofs_per_face</tt> times
- * <tt>this->dofs_per_face</tt>.
+ * then <tt>source.#dofs_per_face</tt> times
+ * <tt>this->#dofs_per_face</tt>.
*
* Derived elements will have to
* implement this function. They
* of one element to the subface of
* the neighboring element.
* The size of the matrix is
- * then <tt>source.dofs_per_face</tt> times
- * <tt>this->dofs_per_face</tt>.
+ * then <tt>source.#dofs_per_face</tt> times
+ * <tt>this->#dofs_per_face</tt>.
*
* Derived elements will have to
* implement this function. They
* implementational question
* about comparing arrays and do
* not compare the matrix arrays
- * @p restriction and
- * @p prolongation.
+ * #restriction and
+ * #prolongation.
*/
bool operator == (const FiniteElement<dim> &) const;
* cannot be associated with one
* vector component, and an
* exception of type
- * @p ExcShapeFunctionNotPrimitive
+ * ExcShapeFunctionNotPrimitive
* will be raised.
*
* Note that if the element is
* that has more than one
* vector-component). For this
* information, refer to the
- * @p system_to_base_table field
+ * #system_to_base_table field
* and the
- * @p system_to_base_index
+ * system_to_base_index()
* function.
*
* The use of this function is
* overall index.
*
* This is the opposite operation
- * from the @p system_to_component_index
+ * from the system_to_component_index()
* function.
*/
unsigned int component_to_system_index(const unsigned int component,
* and their indices on a
* face. The range of allowed
* indices is therefore
- * 0..dofs_per_face.
+ * 0..#dofs_per_face.
*
* You will rarely need this
* function in application
/**
* Return in which of the vector
* components of this finite
- * element the @p ithe shape
+ * element the @p ith shape
* function is non-zero. The
* length of the returned array
* is equal to the number of
* that case, the component with
* the single zero is also the
* first element of what
- * <tt>system_to_component_index(i)</tt>
+ * system_to_component_index()
* returns.
*
* Only for those
* value equals the number of
* entries equal to @p true in
* the result of the
- * @p get_nonzero_components
+ * get_nonzero_components()
* function.
*
* For most finite element
* Since this is an extremely
* common operation, the result
* is cached in the
- * @p cached_primitivity
+ * #cached_primitivity
* variable which is computed in
* the constructor.
*/
* Access to base element
* objects. If the element is
* scalar, then
- * <tt>base_element(0)</tt> is
+ * #base_element(0) is
* @p this.
*/
virtual
* the element is scalar, then
* the result is always equal to
* one. See the documentation for
- * the @p n_base_elements
+ * the n_base_elements()
* function for more details.
*/
virtual
* then base values and dof
* indices within this element
* are equal to the
- * @p system_to_component_table. It
+ * #system_to_component_table. It
* differs only in case the
* element is composed of other
* elements and at least one of
* vector-valued
* (i.e. non-primitive) shape
* functions, in contrast to the
- * @p system_to_component_index
+ * system_to_component_index()
* function.
*/
std::pair<std::pair<unsigned int, unsigned int>, unsigned int>
/**
* Same as
- * @p system_to_base_index, but
+ * system_to_base_index(), but
* for degrees of freedom located
* on a face. The range of allowed
* indices is therefore
- * 0..dofs_per_face.
+ * 0..#dofs_per_face.
*
* You will rarely need this
* function in application
* implementing a certain vector
* component, which can be done
* using this function and the
- * FESystem::@p base_element
+ * FESystem::base_element()
* function.
*
* If this is a scalar finite
* element has defined support
* points. If the result is true,
* then a call to the
- * @p get_unit_support_points
+ * get_unit_support_points()
* yields a non-empty array.
*
* The result may be false if an
* points. In this way, you can
* still ask for certain support
* points, even if
- * @p get_unit_support_points
+ * get_unit_support_points()
* only returns an empty array.
*/
virtual
* support points, then their
* number equals the number of
* degrees of freedom on the face
- * (@p dofs_per_face). The order
+ * (#dofs_per_face). The order
* of points in the array matches
* that returned by the
* <tt>cell->get_dof_indices</tt>
* element has defined support
* points on faces. If the result
* is true, then a call to the
- * @p get_unit_support_points
+ * get_unit_face_support_points()
* yields a non-empty array.
*
* For more information, see the
get_generalized_support_points () const;
/**
-//TODO[GK]: comment this function
- *
+ * Returns <tt>true</tt> if the
+ * class provides nonempty
+ * vectors either from
+ * get_unit_support_points() or
+ * get_generalized_support_points().
*/
bool has_generalized_support_points () const;
/**
* Return whether a finite
- * element has defined support
+ * element has defined
+ * generalized support
* points on faces. If the result
* is true, then a call to the
- * @p get_unit_support_points
+ * get_generalized_face_support_points
* yields a non-empty array.
*
* For more information, see the
/**
* Same for the faces. See the
* description of the
- * @p get_unit_face_support_points
+ * get_unit_face_support_points()
* function for a discussion of
* what contributes a face
* support point.
* 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 <code>
- * dofs_per_quad * 8 </code>, where 8 is
+ * #dofs_per_quad * 8 </code>, where 8 is
* the number of orientations, a face can
* be in (all comibinations of the three
* bool flags face_orientation, face_flip
* 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_line.
+ * empty. In 3D it has the size of
+ * #dofs_per_line.
*
* The standard implementation fills this
* with zeros, i.e. no permuatation at
* Determine the values a finite
* element should compute on
* initialization of data for
- * @p FEValues.
+ * FEValues.
*
* Given a set of flags
* indicating what quantities are
- * requested from a @p FEValues
- * object, @p update_once and
- * @p update_each compute which
+ * requested from a FEValues
+ * object, update_once() and
+ * update_each() compute which
* values must really be
* computed. Then, the
* <tt>fill_*_values</tt> functions
* computed either on the unit
* cell or on the physical
* cell. For instance, the
- * function values of @p FE_Q do
+ * function values of FE_Q do
* only depend on the quadrature
* points on the unit
* cell. Therefore, this flags
* will be returned by
- * @p update_once. The gradients
+ * update_once(). The gradients
* require computation of the
* covariant transformation
* matrix. Therefore,
* @p update_covariant_transformation
* and @p update_gradients will
* be returned by
- * @p update_each.
+ * update_each().
*
* For an example see the same
* function in the derived class
- * @p FE_Q.
+ * FE_Q.
*/
virtual UpdateFlags update_once (const UpdateFlags flags) const = 0;
/**
* Complementary function for
- * @p update_once.
+ * update_once().
*
- * While @p update_once returns
+ * While update_once() returns
* the values to be computed on
* the unit cell for yielding the
* required data, this function
* must be recomputed on each
* cell.
*
- * Refer to @p update_once for
+ * Refer to update_once() for
* more details.
*/
virtual UpdateFlags update_each (const UpdateFlags flags) const = 0;
private:
/**
* Store what
- * @p system_to_component_index
+ * system_to_component_index()
* will return.
*/
std::vector< std::pair<unsigned int, unsigned int> > system_to_component_table;
* then base values and dof
* indices within this element
* are equal to the
- * @p system_to_component_table. It
+ * #system_to_component_table. It
* differs only in case the
* element is composed of other
* elements and at least one of
* vector-valued
* (i.e. non-primitive) shape
* functions, in contrast to the
- * @p system_to_component_table.
+ * #system_to_component_table.
*/
std::vector<std::pair<std::pair<unsigned int,unsigned int>,unsigned int> >
system_to_base_table;
* this flag in the vector-valued
* case: this used to be done
* with the
- * @p system_to_component_index
+ * #system_to_component_index
* function that returns which
* vector component a shape
* function is associated
/**
* This array holds how many
* values in the respective entry
- * of the @p nonzero_components
+ * of the #nonzero_components
* element are non-zero. The
* array is thus a short-cut to
* allow faster access to this
* FEValues. This function
* performs all the operations
* needed to compute the data of an
- * @p FEValues object.
+ * FEValues object.
*
* The same function in
* @p mapping must have been
* FEFaceValues. This function
* performs all the operations
* needed to compute the data of an
- * @p FEFaceValues object.
+ * FEFaceValues object.
*
* The same function in
* @p mapping must have been
* FESubfaceValues. This function
* performs all the operations
* needed to compute the data of an
- * @p FESubfaceValues object.
+ * FESubfaceValues object.
*
* The same function in
* @p mapping must have been
projects / dealii-svn.git / commitdiff