From 9f67131c065c9163eb17eba07b452015cc2bf639 Mon Sep 17 00:00:00 2001 From: heister Date: Tue, 19 Nov 2013 15:14:30 +0000 Subject: [PATCH] rewrap comments (phew) git-svn-id: https://svn.dealii.org/trunk@31709 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/include/deal.II/fe/fe_values.h | 3294 ++++++++---------------- 1 file changed, 1051 insertions(+), 2243 deletions(-) diff --git a/deal.II/include/deal.II/fe/fe_values.h b/deal.II/include/deal.II/fe/fe_values.h index f1791659bf..994f7885f2 100644 --- a/deal.II/include/deal.II/fe/fe_values.h +++ b/deal.II/include/deal.II/fe/fe_values.h @@ -60,19 +60,15 @@ template class BlockVector; namespace internal { /** - * A class whose specialization is - * used to define what type the - * curl of a vector valued function - * corresponds to. + * A class whose specialization is used to define what type the curl of a + * vector valued function corresponds to. */ template struct CurlType; /** - * A class whose specialization is - * used to define what type the - * curl of a vector valued function - * corresponds to. + * A class whose specialization is used to define what type the curl of a + * vector valued function corresponds to. * * In 1d, the curl is a scalar. */ @@ -83,10 +79,8 @@ namespace internal }; /** - * A class whose specialization is - * used to define what type the - * curl of a vector valued function - * corresponds to. + * A class whose specialization is used to define what type the curl of a + * vector valued function corresponds to. * * In 2d, the curl is a scalar. */ @@ -97,10 +91,8 @@ namespace internal }; /** - * A class whose specialization is - * used to define what type the - * curl of a vector valued function - * corresponds to. + * A class whose specialization is used to define what type the curl of a + * vector valued function corresponds to. * * In 3d, the curl is a vector. */ @@ -124,10 +116,10 @@ namespace internal * FEValuesExtractors objects to a FEValues, FEFaceValues or FESubfaceValues * objects using the square bracket operator. * - * There are classes that present views for single scalar components, - * vector components consisting of dim elements, and - * symmetric second order tensor components - * consisting of (dim*dim + dim)/2 elements + * There are classes that present views for single scalar components, vector + * components consisting of dim elements, and symmetric second + * order tensor components consisting of (dim*dim + dim)/2 + * elements * * See the description of the @ref vector_valued module for examples how to * use the features of this namespace. @@ -137,16 +129,12 @@ namespace internal namespace FEValuesViews { /** - * A class representing a view to a single - * scalar component of a possibly - * vector-valued finite element. Views are - * discussed in the @ref vector_valued - * module. + * A class representing a view to a single scalar component of a possibly + * vector-valued finite element. Views are discussed in the @ref + * vector_valued module. * - * You get an object of this type if you - * apply a FEValuesExtractors::Scalar to an - * FEValues, FEFaceValues or - * FESubfaceValues object. + * You get an object of this type if you apply a FEValuesExtractors::Scalar + * to an FEValues, FEFaceValues or FESubfaceValues object. * * @ingroup feaccess vector_valued */ @@ -155,131 +143,93 @@ namespace FEValuesViews { public: /** - * A typedef for the data type of - * values of the view this class - * represents. Since we deal with a - * single components, the value type is - * a scalar double. + * A typedef for the data type of values of the view this class + * represents. Since we deal with a single components, the value type is a + * scalar double. */ typedef double value_type; /** - * A typedef for the type of gradients - * of the view this class - * represents. Here, for a scalar - * component of the finite element, the - * gradient is a - * Tensor@<1,dim@>. + * A typedef for the type of gradients of the view this class + * represents. Here, for a scalar component of the finite element, the + * gradient is a Tensor@<1,dim@>. */ typedef dealii::Tensor<1,spacedim> gradient_type; /** - * A typedef for the type of second - * derivatives of the view this class - * represents. Here, for a scalar - * component of the finite element, the - * Hessian is a - * Tensor@<2,dim@>. + * A typedef for the type of second derivatives of the view this class + * represents. Here, for a scalar component of the finite element, the + * Hessian is a Tensor@<2,dim@>. */ typedef dealii::Tensor<2,spacedim> hessian_type; /** - * A structure where for each shape - * function we pre-compute a bunch of - * data that will make later accesses - * much cheaper. + * A structure where for each shape function we pre-compute a bunch of + * data that will make later accesses much cheaper. */ struct ShapeFunctionData { /** - * For each shape function, store - * whether the selected vector - * component may be nonzero. For - * primitive shape functions we - * know for sure whether a certain - * scalar component of a given - * shape function is nonzero, - * whereas for non-primitive shape - * functions this may not be - * entirely clear (e.g. for RT - * elements it depends on the shape - * of a cell). + * For each shape function, store whether the selected vector component + * may be nonzero. For primitive shape functions we know for sure + * whether a certain scalar component of a given shape function is + * nonzero, whereas for non-primitive shape functions this may not be + * entirely clear (e.g. for RT elements it depends on the shape of a + * cell). */ bool is_nonzero_shape_function_component; /** - * For each shape function, store - * the row index within the - * shape_values, shape_gradients, - * and shape_hessians tables (the - * column index is the quadrature - * point index). If the shape - * function is primitive, then we - * can get this information from - * the shape_function_to_row_table - * of the FEValues object; - * otherwise, we have to work a bit - * harder to compute this - * information. + * For each shape function, store the row index within the shape_values, + * shape_gradients, and shape_hessians tables (the column index is the + * quadrature point index). If the shape function is primitive, then we + * can get this information from the shape_function_to_row_table of the + * FEValues object; otherwise, we have to work a bit harder to compute + * this information. */ unsigned int row_index; }; /** - * Default constructor. Creates an - * invalid object. + * Default constructor. Creates an invalid object. */ Scalar (); /** - * Constructor for an object that - * represents a single scalar component - * of a FEValuesBase object (or of one - * of the classes derived from + * Constructor for an object that represents a single scalar component of + * a FEValuesBase object (or of one of the classes derived from * FEValuesBase). */ Scalar (const FEValuesBase &fe_values_base, const unsigned int component); /** - * Copy operator. This is not a - * lightweight object so we don't allow - * copying and generate an exception if - * this function is called. + * Copy operator. This is not a lightweight object so we don't allow + * copying and generate an exception if this function is called. */ Scalar &operator= (const Scalar &); /** - * Return the value of the vector - * component selected by this view, for - * the shape function and quadrature - * point selected by the arguments. + * Return the value of the vector component selected by this view, for the + * shape function and quadrature point selected by the arguments. * - * @param shape_function Number - * of the shape function to be - * evaluated. Note that this - * number runs from zero to - * dofs_per_cell, even in the - * case of an FEFaceValues or - * FESubfaceValues object. + * @param shape_function Number of the shape function to be + * evaluated. Note that this number runs from zero to dofs_per_cell, even + * in the case of an FEFaceValues or FESubfaceValues object. * - * @param q_point Number of - * the quadrature point at which - * function is to be evaluated + * @param q_point Number of the quadrature point at which function is to + * be evaluated */ value_type value (const unsigned int shape_function, const unsigned int q_point) const; /** - * Return the gradient (a tensor of - * rank 1) of the vector component - * selected by this view, for the shape - * function and quadrature point + * Return the gradient (a tensor of rank 1) of the vector component + * selected by this view, for the shape function and quadrature point * selected by the arguments. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ gradient_type @@ -287,15 +237,11 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the Hessian (the tensor of - * rank 2 of all second derivatives) of - * the vector component selected by - * this view, for the shape function - * and quadrature point selected by the - * arguments. + * Return the Hessian (the tensor of rank 2 of all second derivatives) of + * the vector component selected by this view, for the shape function and + * quadrature point selected by the arguments. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ hessian_type @@ -303,19 +249,13 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the values of the selected - * scalar component of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the values of the selected scalar component of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_values - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_values function but it only works on the * selected scalar component. */ template @@ -323,19 +263,13 @@ namespace FEValuesViews std::vector &values) const; /** - * Return the gradients of the selected - * scalar component of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the gradients of the selected scalar component of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_gradients - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_gradients function but it only works on the * selected scalar component. */ template @@ -343,19 +277,13 @@ namespace FEValuesViews std::vector &gradients) const; /** - * Return the Hessians of the selected - * scalar component of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the Hessians of the selected scalar component of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_hessians - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_hessians function but it only works on the * selected scalar component. */ template @@ -363,25 +291,15 @@ namespace FEValuesViews std::vector &hessians) const; /** - * Return the Laplacians of the - * selected scalar component of - * the finite element function - * characterized by - * fe_function at the - * quadrature points of the - * cell, face or subface - * selected the last time the - * reinit function of - * the FEValues object was - * called. The Laplacians are - * the trace of the Hessians. + * Return the Laplacians of the selected scalar component of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. The + * Laplacians are the trace of the Hessians. * - * This function is the - * equivalent of the - * FEValuesBase::get_function_laplacians - * function but it only works - * on the selected scalar - * component. + * This function is the equivalent of the + * FEValuesBase::get_function_laplacians function but it only works on the + * selected scalar component. */ template void get_function_laplacians (const InputVector &fe_function, @@ -389,21 +307,18 @@ namespace FEValuesViews private: /** - * A reference to the FEValuesBase object - * we operate on. + * A reference to the FEValuesBase object we operate on. */ const FEValuesBase &fe_values; /** - * The single scalar component this - * view represents of the FEValuesBase + * The single scalar component this view represents of the FEValuesBase * object. */ const unsigned int component; /** - * Store the data about shape - * functions. + * Store the data about shape functions. */ std::vector shape_function_data; }; @@ -411,50 +326,29 @@ namespace FEValuesViews /** - * A class representing a view to a set of - * spacedim components forming a - * vector part of a vector-valued finite - * element. Views are discussed in the - * @ref vector_valued module. + * A class representing a view to a set of spacedim components + * forming a vector part of a vector-valued finite element. Views are + * discussed in the @ref vector_valued module. * - * Note that in the current context, a - * vector is meant in the sense physics - * uses it: it has spacedim - * components that behave in specific ways - * under coordinate system - * transformations. Examples include - * velocity or displacement fields. This is - * opposed to how mathematics uses the word - * "vector" (and how we use this word in - * other contexts in the library, for - * example in the Vector class), where it - * really stands for a collection of - * numbers. An example of this latter use - * of the word could be the set of - * concentrations of chemical species in a - * flame; however, these are really just a - * collection of scalar variables, since - * they do not change if the coordinate - * system is rotated, unlike the components - * of a velocity vector, and consequently, - * this class should not be used for this - * context. + * Note that in the current context, a vector is meant in the sense physics + * uses it: it has spacedim components that behave in specific + * ways under coordinate system transformations. Examples include velocity + * or displacement fields. This is opposed to how mathematics uses the word + * "vector" (and how we use this word in other contexts in the library, for + * example in the Vector class), where it really stands for a collection of + * numbers. An example of this latter use of the word could be the set of + * concentrations of chemical species in a flame; however, these are really + * just a collection of scalar variables, since they do not change if the + * coordinate system is rotated, unlike the components of a velocity vector, + * and consequently, this class should not be used for this context. * - * This class allows to query the - * value, gradient and divergence of - * (components of) shape functions - * and solutions representing - * vectors. The - * gradient of a vector - * $d_{k}, 0\le k<\text{dim}$ is - * defined as - * $S_{ij} = \frac{\partial d_{i}}{\partial x_j}, - * 0\le i,j<\text{dim}$. + * This class allows to query the value, gradient and divergence of + * (components of) shape functions and solutions representing vectors. The + * gradient of a vector $d_{k}, 0\le k<\text{dim}$ is defined as $S_{ij} = + * \frac{\partial d_{i}}{\partial x_j}, 0\le i,j<\text{dim}$. * - * You get an object of this type if you - * apply a FEValuesExtractors::Vector to an - * FEValues, FEFaceValues or - * FESubfaceValues object. + * You get an object of this type if you apply a FEValuesExtractors::Vector + * to an FEValues, FEFaceValues or FESubfaceValues object. * * @ingroup feaccess vector_valued */ @@ -463,209 +357,144 @@ namespace FEValuesViews { public: /** - * A typedef for the data type of - * values of the view this class - * represents. Since we deal with a set - * of dim components, the - * value type is a Tensor<1,spacedim>. + * A typedef for the data type of values of the view this class + * represents. Since we deal with a set of dim components, + * the value type is a Tensor<1,spacedim>. */ typedef dealii::Tensor<1,spacedim> value_type; /** - * A typedef for the type of gradients - * of the view this class - * represents. Here, for a set of - * dim components of the - * finite element, the gradient is a - * Tensor@<2,spacedim@>. + * A typedef for the type of gradients of the view this class + * represents. Here, for a set of dim components of the + * finite element, the gradient is a Tensor@<2,spacedim@>. * - * See the general documentation of this class for how exactly - * the gradient of a vector is defined. + * See the general documentation of this class for how exactly the + * gradient of a vector is defined. */ typedef dealii::Tensor<2,spacedim> gradient_type; /** - * A typedef for the type of - * symmetrized gradients of the view - * this class represents. Here, for a - * set of dim components - * of the finite element, the - * symmetrized gradient is a + * A typedef for the type of symmetrized gradients of the view this class + * represents. Here, for a set of dim components of the + * finite element, the symmetrized gradient is a * SymmetricTensor@<2,spacedim@>. * - * The symmetric gradient of a vector - * field $\mathbf v$ is defined as - * $\varepsilon(\mathbf v)=\frac 12 - * (\nabla \mathbf v + \nabla \mathbf + * The symmetric gradient of a vector field $\mathbf v$ is defined as + * $\varepsilon(\mathbf v)=\frac 12 (\nabla \mathbf v + \nabla \mathbf * v^T)$. */ typedef dealii::SymmetricTensor<2,spacedim> symmetric_gradient_type; /** - * A typedef for the type of the - * divergence of the view this class - * represents. Here, for a set of - * dim components of the - * finite element, the divergence of - * course is a scalar. + * A typedef for the type of the divergence of the view this class + * represents. Here, for a set of dim components of the + * finite element, the divergence of course is a scalar. */ typedef double divergence_type; /** - * A typedef for the type of the - * curl of the view this class - * represents. Here, for a set of - * spacedim=2 components - * of the finite element, the curl is - * a Tensor@<1, 1@>. For - * spacedim=3 it is a - * Tensor@<1, dim@>. + * A typedef for the type of the curl of the view this class + * represents. Here, for a set of spacedim=2 components of + * the finite element, the curl is a Tensor@<1, 1@>. For + * spacedim=3 it is a Tensor@<1, dim@>. */ typedef typename dealii::internal::CurlType::type curl_type; /** - * A typedef for the type of second - * derivatives of the view this class - * represents. Here, for a set of - * dim components of the - * finite element, the Hessian is a - * Tensor@<3,dim@>. + * A typedef for the type of second derivatives of the view this class + * represents. Here, for a set of dim components of the + * finite element, the Hessian is a Tensor@<3,dim@>. */ typedef dealii::Tensor<3,spacedim> hessian_type; /** - * A structure where for each shape - * function we pre-compute a bunch of - * data that will make later accesses - * much cheaper. + * A structure where for each shape function we pre-compute a bunch of + * data that will make later accesses much cheaper. */ struct ShapeFunctionData { /** - * For each pair (shape - * function,component within - * vector), store whether the - * selected vector component may be - * nonzero. For primitive shape - * functions we know for sure - * whether a certain scalar - * component of a given shape - * function is nonzero, whereas for - * non-primitive shape functions - * this may not be entirely clear - * (e.g. for RT elements it depends - * on the shape of a cell). + * For each pair (shape function,component within vector), store whether + * the selected vector component may be nonzero. For primitive shape + * functions we know for sure whether a certain scalar component of a + * given shape function is nonzero, whereas for non-primitive shape + * functions this may not be entirely clear (e.g. for RT elements it + * depends on the shape of a cell). */ bool is_nonzero_shape_function_component[spacedim]; /** - * For each pair (shape function, - * component within vector), store - * the row index within the - * shape_values, shape_gradients, - * and shape_hessians tables (the - * column index is the quadrature - * point index). If the shape - * function is primitive, then we - * can get this information from - * the shape_function_to_row_table - * of the FEValues object; - * otherwise, we have to work a bit - * harder to compute this + * For each pair (shape function, component within vector), store the + * row index within the shape_values, shape_gradients, and + * shape_hessians tables (the column index is the quadrature point + * index). If the shape function is primitive, then we can get this + * information from the shape_function_to_row_table of the FEValues + * object; otherwise, we have to work a bit harder to compute this * information. */ unsigned int row_index[spacedim]; /** - * For each shape function say the - * following: if only a single - * entry in - * is_nonzero_shape_function_component - * for this shape function is - * nonzero, then store the - * corresponding value of row_index - * and - * single_nonzero_component_index - * represents the index between 0 - * and dim for which it is - * attained. If multiple components - * are nonzero, then store -1. If - * no components are nonzero then - * store -2. + * For each shape function say the following: if only a single entry in + * is_nonzero_shape_function_component for this shape function is + * nonzero, then store the corresponding value of row_index and + * single_nonzero_component_index represents the index between 0 and dim + * for which it is attained. If multiple components are nonzero, then + * store -1. If no components are nonzero then store -2. */ int single_nonzero_component; unsigned int single_nonzero_component_index; }; /** - * Default constructor. Creates an - * invalid object. + * Default constructor. Creates an invalid object. */ Vector (); /** - * Constructor for an object that - * represents dim components of a - * FEValuesBase object (or of one of - * the classes derived from - * FEValuesBase), representing a - * vector-valued variable. + * Constructor for an object that represents dim components of a + * FEValuesBase object (or of one of the classes derived from + * FEValuesBase), representing a vector-valued variable. * - * The second argument denotes the - * index of the first component of the + * The second argument denotes the index of the first component of the * selected vector. */ Vector (const FEValuesBase &fe_values_base, const unsigned int first_vector_component); /** - * Copy operator. This is not a - * lightweight object so we don't allow - * copying and generate an exception if - * this function is called. + * Copy operator. This is not a lightweight object so we don't allow + * copying and generate an exception if this function is called. */ Vector &operator= (const Vector &); /** - * Return the value of the vector - * components selected by this view, - * for the shape function and - * quadrature point selected by the - * arguments. Here, since the view - * represents a vector-valued part of - * the FEValues object with - * dim components, the - * return type is a tensor of rank 1 - * with dim components. + * Return the value of the vector components selected by this view, for + * the shape function and quadrature point selected by the + * arguments. Here, since the view represents a vector-valued part of the + * FEValues object with dim components, the return type is a + * tensor of rank 1 with dim components. * - * @param shape_function Number - * of the shape function to be - * evaluated. Note that this - * number runs from zero to - * dofs_per_cell, even in the - * case of an FEFaceValues or - * FESubfaceValues object. + * @param shape_function Number of the shape function to be + * evaluated. Note that this number runs from zero to dofs_per_cell, even + * in the case of an FEFaceValues or FESubfaceValues object. * - * @param q_point Number of - * the quadrature point at which - * function is to be evaluated + * @param q_point Number of the quadrature point at which function is to + * be evaluated */ value_type value (const unsigned int shape_function, const unsigned int q_point) const; /** - * Return the gradient (a tensor of - * rank 2) of the vector component - * selected by this view, for the shape - * function and quadrature point + * Return the gradient (a tensor of rank 2) of the vector component + * selected by this view, for the shape function and quadrature point * selected by the arguments. * - * See the general documentation of this class for how exactly - * the gradient of a vector is defined. + * See the general documentation of this class for how exactly the + * gradient of a vector is defined. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ gradient_type @@ -673,24 +502,16 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the symmetric gradient (a - * symmetric tensor of rank 2) of the - * vector component selected by this - * view, for the shape function and - * quadrature point selected by the - * arguments. + * Return the symmetric gradient (a symmetric tensor of rank 2) of the + * vector component selected by this view, for the shape function and + * quadrature point selected by the arguments. * - * The symmetric gradient is defined as - * $\frac 12 [(\nabla \phi_i(x_q)) + - * (\nabla \phi_i(x_q))^T]$, where - * $\phi_i$ represents the - * dim components selected - * from the FEValuesBase object, and - * $x_q$ is the location of the $q$-th - * quadrature point. + * The symmetric gradient is defined as $\frac 12 [(\nabla \phi_i(x_q)) + + * (\nabla \phi_i(x_q))^T]$, where $\phi_i$ represents the + * dim components selected from the FEValuesBase object, and + * $x_q$ is the location of the $q$-th quadrature point. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ symmetric_gradient_type @@ -698,14 +519,11 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the scalar divergence of - * the vector components selected by - * this view, for the shape function - * and quadrature point selected by the + * Return the scalar divergence of the vector components selected by this + * view, for the shape function and quadrature point selected by the * arguments. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ divergence_type @@ -713,31 +531,17 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the vector curl of - * the vector components selected by - * this view, for the shape function - * and quadrature point selected by the - * arguments. For 1d this function does - * not make any sense. Thus it is not - * implemented for spacedim=1. - * In 2d the curl is defined as - * @f{equation*} - * \operatorname{curl}(u):=\frac{du_2}{dx} - * -\frac{du_1}{dy}, - * @f} - * whereas in 3d it is given by - * @f{equation*} - * \operatorname{curl}(u):=\left( - * \begin{array}{c} - * \frac{du_3}{dy}-\frac{du_2}{dz}\\ - * \frac{du_1}{dz}-\frac{du_3}{dx}\\ - * \frac{du_2}{dx}-\frac{du_1}{dy} - * \end{array} - * \right). - * @f} + * Return the vector curl of the vector components selected by this view, + * for the shape function and quadrature point selected by the + * arguments. For 1d this function does not make any sense. Thus it is not + * implemented for spacedim=1. In 2d the curl is defined as + * @f{equation*} \operatorname{curl}(u):=\frac{du_2}{dx} -\frac{du_1}{dy}, + * @f} whereas in 3d it is given by @f{equation*} + * \operatorname{curl}(u):=\left( \begin{array}{c} + * \frac{du_3}{dy}-\frac{du_2}{dz}\\ \frac{du_1}{dz}-\frac{du_3}{dx}\\ + * \frac{du_2}{dx}-\frac{du_1}{dy} \end{array} \right). @f} * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ curl_type @@ -745,15 +549,11 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the Hessian (the tensor of - * rank 2 of all second derivatives) of - * the vector components selected by - * this view, for the shape function - * and quadrature point selected by the - * arguments. + * Return the Hessian (the tensor of rank 2 of all second derivatives) of + * the vector components selected by this view, for the shape function and + * quadrature point selected by the arguments. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ hessian_type @@ -761,19 +561,13 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the values of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the values of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_values - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_values function but it only works on the * selected vector components. */ template @@ -781,19 +575,13 @@ namespace FEValuesViews std::vector &values) const; /** - * Return the gradients of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the gradients of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_gradients - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_gradients function but it only works on the * selected vector components. */ template @@ -801,29 +589,19 @@ namespace FEValuesViews std::vector &gradients) const; /** - * Return the symmetrized gradients of - * the selected vector components of - * the finite element function - * characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the symmetrized gradients of the selected vector components of + * the finite element function characterized by fe_function at + * the quadrature points of the cell, face or subface selected the last + * time the reinit function of the FEValues object was called. * - * The symmetric gradient of a vector - * field $\mathbf v$ is defined as - * $\varepsilon(\mathbf v)=\frac 12 - * (\nabla \mathbf v + \nabla \mathbf + * The symmetric gradient of a vector field $\mathbf v$ is defined as + * $\varepsilon(\mathbf v)=\frac 12 (\nabla \mathbf v + \nabla \mathbf * v^T)$. * - * @note There is no equivalent - * function such as - * FEValuesBase::get_function_symmetric_gradients - * in the FEValues classes but the - * information can be obtained from - * FEValuesBase::get_function_gradients, - * of course. + * @note There is no equivalent function such as + * FEValuesBase::get_function_symmetric_gradients in the FEValues classes + * but the information can be obtained from + * FEValuesBase::get_function_gradients, of course. */ template void @@ -831,21 +609,14 @@ namespace FEValuesViews std::vector &symmetric_gradients) const; /** - * Return the divergence of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the divergence of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * There is no equivalent function such - * as - * FEValuesBase::get_function_divergences - * in the FEValues classes but the - * information can be obtained from - * FEValuesBase::get_function_gradients, + * There is no equivalent function such as + * FEValuesBase::get_function_divergences in the FEValues classes but the + * information can be obtained from FEValuesBase::get_function_gradients, * of course. */ template @@ -853,21 +624,14 @@ namespace FEValuesViews std::vector &divergences) const; /** - * Return the curl of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the curl of the selected vector components of the finite element + * function characterized by fe_function at the quadrature points + * of the cell, face or subface selected the last time the reinit + * function of the FEValues object was called. * - * There is no equivalent function such - * as - * FEValuesBase::get_function_curls - * in the FEValues classes but the - * information can be obtained from - * FEValuesBase::get_function_gradients, + * There is no equivalent function such as + * FEValuesBase::get_function_curls in the FEValues classes but the + * information can be obtained from FEValuesBase::get_function_gradients, * of course. */ template @@ -875,19 +639,13 @@ namespace FEValuesViews std::vector &curls) const; /** - * Return the Hessians of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the Hessians of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_hessians - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_hessians function but it only works on the * selected vector components. */ template @@ -895,25 +653,15 @@ namespace FEValuesViews std::vector &hessians) const; /** - * Return the Laplacians of the - * selected vector components - * of the finite element - * function characterized by - * fe_function at the - * quadrature points of the - * cell, face or subface - * selected the last time the - * reinit function of - * the FEValues object was - * called. The Laplacians are - * the trace of the Hessians. + * Return the Laplacians of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. The + * Laplacians are the trace of the Hessians. * - * This function is the - * equivalent of the - * FEValuesBase::get_function_laplacians - * function but it only works - * on the selected vector - * components. + * This function is the equivalent of the + * FEValuesBase::get_function_laplacians function but it only works on the + * selected vector components. */ template void get_function_laplacians (const InputVector &fe_function, @@ -921,21 +669,18 @@ namespace FEValuesViews private: /** - * A reference to the FEValuesBase object - * we operate on. + * A reference to the FEValuesBase object we operate on. */ const FEValuesBase &fe_values; /** - * The first component of the vector - * this view represents of the + * The first component of the vector this view represents of the * FEValuesBase object. */ const unsigned int first_vector_component; /** - * Store the data about shape - * functions. + * Store the data about shape functions. */ std::vector shape_function_data; }; @@ -945,34 +690,21 @@ namespace FEValuesViews class SymmetricTensor; /** - * A class representing a view to a set of - * (dim*dim + dim)/2 components forming a - * symmetric second-order tensor from a - * vector-valued finite - * element. Views are discussed in the - * @ref vector_valued module. + * A class representing a view to a set of (dim*dim + dim)/2 + * components forming a symmetric second-order tensor from a vector-valued + * finite element. Views are discussed in the @ref vector_valued module. * - * This class allows to query the - * value and divergence of - * (components of) shape functions - * and solutions representing - * symmetric tensors. The - * divergence of a symmetric tensor - * $S_{ij}, 0\le i,j<\text{dim}$ is - * defined as - * $d_i = \sum_j \frac{\partial S_{ij}}{\partial x_j}, - * 0\le i<\text{dim}$, - * which due to the symmetry of the tensor is also - * $d_i = \sum_j \frac{\partial S_{ji}}{\partial x_j}$. - * In other words, it due to the symmetry - * of $S$ it does not matter whether - * we apply the nabla operator by row - * or by column to get the divergence. + * This class allows to query the value and divergence of (components of) + * shape functions and solutions representing symmetric tensors. The + * divergence of a symmetric tensor $S_{ij}, 0\le i,j<\text{dim}$ is defined + * as $d_i = \sum_j \frac{\partial S_{ij}}{\partial x_j}, 0\le + * i<\text{dim}$, which due to the symmetry of the tensor is also $d_i = + * \sum_j \frac{\partial S_{ji}}{\partial x_j}$. In other words, it due to + * the symmetry of $S$ it does not matter whether we apply the nabla + * operator by row or by column to get the divergence. * - * You get an object of this type if you - * apply a - * FEValuesExtractors::SymmetricTensor to - * an FEValues, FEFaceValues or + * You get an object of this type if you apply a + * FEValuesExtractors::SymmetricTensor to an FEValues, FEFaceValues or * FESubfaceValues object. * * @ingroup feaccess vector_valued @@ -984,149 +716,100 @@ namespace FEValuesViews { public: /** - * A typedef for the data type of - * values of the view this class - * represents. Since we deal with a set - * of (dim*dim + dim)/2 components - * (i.e. the unique components of a symmetric second-order + * A typedef for the data type of values of the view this class + * represents. Since we deal with a set of (dim*dim + dim)/2 + * components (i.e. the unique components of a symmetric second-order * tensor), the value type is a SymmetricTensor<2,spacedim>. */ typedef dealii::SymmetricTensor<2, spacedim> value_type; /** - * A typedef for the type of the - * divergence of the view this class - * represents. Here, for a set of - * of (dim*dim + dim)/2 unique components - * of the finite element representing a symmetric second-order - * tensor, the divergence of - * course is a * Tensor@<1,dim@>. + * A typedef for the type of the divergence of the view this class + * represents. Here, for a set of of (dim*dim + dim)/2 unique + * components of the finite element representing a symmetric second-order + * tensor, the divergence of course is a * Tensor@<1,dim@>. * - * See the general discussion - * of this class for a - * definition of the + * See the general discussion of this class for a definition of the * divergence. */ typedef dealii::Tensor<1, spacedim> divergence_type; /** - * A structure where for each shape - * function we pre-compute a bunch of - * data that will make later accesses - * much cheaper. + * A structure where for each shape function we pre-compute a bunch of + * data that will make later accesses much cheaper. */ struct ShapeFunctionData { /** - * For each pair (shape - * function,component within - * vector), store whether the - * selected vector component may be - * nonzero. For primitive shape - * functions we know for sure - * whether a certain scalar - * component of a given shape - * function is nonzero, whereas for - * non-primitive shape functions - * this may not be entirely clear - * (e.g. for RT elements it depends - * on the shape of a cell). + * For each pair (shape function,component within vector), store whether + * the selected vector component may be nonzero. For primitive shape + * functions we know for sure whether a certain scalar component of a + * given shape function is nonzero, whereas for non-primitive shape + * functions this may not be entirely clear (e.g. for RT elements it + * depends on the shape of a cell). */ bool is_nonzero_shape_function_component[value_type::n_independent_components]; /** - * For each pair (shape function, - * component within vector), store - * the row index within the - * shape_values, shape_gradients, - * and shape_hessians tables (the - * column index is the quadrature - * point index). If the shape - * function is primitive, then we - * can get this information from - * the shape_function_to_row_table - * of the FEValues object; - * otherwise, we have to work a bit - * harder to compute this + * For each pair (shape function, component within vector), store the + * row index within the shape_values, shape_gradients, and + * shape_hessians tables (the column index is the quadrature point + * index). If the shape function is primitive, then we can get this + * information from the shape_function_to_row_table of the FEValues + * object; otherwise, we have to work a bit harder to compute this * information. */ unsigned int row_index[value_type::n_independent_components]; /** - * For each shape function say the - * following: if only a single - * entry in - * is_nonzero_shape_function_component - * for this shape function is - * nonzero, then store the - * corresponding value of row_index - * and - * single_nonzero_component_index - * represents the index between 0 - * and (dim^2 + dim)/2 for which it is - * attained. If multiple components - * are nonzero, then store -1. If - * no components are nonzero then - * store -2. + * For each shape function say the following: if only a single entry in + * is_nonzero_shape_function_component for this shape function is + * nonzero, then store the corresponding value of row_index and + * single_nonzero_component_index represents the index between 0 and + * (dim^2 + dim)/2 for which it is attained. If multiple components are + * nonzero, then store -1. If no components are nonzero then store -2. */ int single_nonzero_component; unsigned int single_nonzero_component_index; }; /** - * Default constructor. Creates an - * invalid object. + * Default constructor. Creates an invalid object. */ SymmetricTensor(); /** - * Constructor for an object that - * represents (dim*dim + dim)/2 - * components of a - * FEValuesBase object (or of one of - * the classes derived from - * FEValuesBase), representing the unique - * components comprising a symmetric second- - * order tensor valued variable. + * Constructor for an object that represents (dim*dim + + * dim)/2 components of a FEValuesBase object (or of one of the + * classes derived from FEValuesBase), representing the unique components + * comprising a symmetric second- order tensor valued variable. * - * The second argument denotes the - * index of the first component of the + * The second argument denotes the index of the first component of the * selected symmetric second order tensor. */ SymmetricTensor(const FEValuesBase &fe_values_base, const unsigned int first_tensor_component); /** - * Copy operator. This is not a - * lightweight object so we don't allow - * copying and generate an exception if - * this function is called. + * Copy operator. This is not a lightweight object so we don't allow + * copying and generate an exception if this function is called. */ SymmetricTensor &operator=(const SymmetricTensor<2, dim, spacedim> &); /** - * Return the value of the vector - * components selected by this view, - * for the shape function and - * quadrature point selected by the - * arguments. Here, since the view - * represents a vector-valued part of - * the FEValues object with - * (dim*dim + dim)/2 components - * (the unique components of a symmetric second-order tensor), - * the return type is a symmetric tensor of rank 2. + * Return the value of the vector components selected by this view, for + * the shape function and quadrature point selected by the + * arguments. Here, since the view represents a vector-valued part of the + * FEValues object with (dim*dim + dim)/2 components (the + * unique components of a symmetric second-order tensor), the return type + * is a symmetric tensor of rank 2. * - * @param shape_function Number - * of the shape function to be - * evaluated. Note that this - * number runs from zero to - * dofs_per_cell, even in the - * case of an FEFaceValues or - * FESubfaceValues object. + * @param shape_function Number of the shape function to be + * evaluated. Note that this number runs from zero to dofs_per_cell, even + * in the case of an FEFaceValues or FESubfaceValues object. * - * @param q_point Number of - * the quadrature point at which - * function is to be evaluated + * @param q_point Number of the quadrature point at which function is to + * be evaluated */ value_type value (const unsigned int shape_function, @@ -1134,19 +817,14 @@ namespace FEValuesViews /** - * Return the vector divergence of - * the vector components selected by - * this view, for the shape function - * and quadrature point selected by the + * Return the vector divergence of the vector components selected by this + * view, for the shape function and quadrature point selected by the * arguments. * - * See the general discussion - * of this class for a - * definition of the + * See the general discussion of this class for a definition of the * divergence. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ divergence_type @@ -1154,19 +832,13 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the values of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the values of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_values - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_values function but it only works on the * selected vector components. */ template @@ -1174,26 +846,17 @@ namespace FEValuesViews std::vector &values) const; /** - * Return the divergence of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the divergence of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * There is no equivalent function such - * as - * FEValuesBase::get_function_divergences - * in the FEValues classes but the - * information can be obtained from - * FEValuesBase::get_function_gradients, + * There is no equivalent function such as + * FEValuesBase::get_function_divergences in the FEValues classes but the + * information can be obtained from FEValuesBase::get_function_gradients, * of course. * - * See the general discussion - * of this class for a - * definition of the + * See the general discussion of this class for a definition of the * divergence. */ template @@ -1202,21 +865,18 @@ namespace FEValuesViews private: /** - * A reference to the FEValuesBase object - * we operate on. + * A reference to the FEValuesBase object we operate on. */ const FEValuesBase &fe_values; /** - * The first component of the vector - * this view represents of the + * The first component of the vector this view represents of the * FEValuesBase object. */ const unsigned int first_tensor_component; /** - * Store the data about shape - * functions. + * Store the data about shape functions. */ std::vector shape_function_data; }; @@ -1226,29 +886,17 @@ namespace FEValuesViews class Tensor; /** - * A class representing a view to a set of - * dim*dim components forming a - * second-order tensor from a - * vector-valued finite - * element. Views are discussed in the - * @ref vector_valued module. + * A class representing a view to a set of dim*dim components + * forming a second-order tensor from a vector-valued finite element. Views + * are discussed in the @ref vector_valued module. * - * This class allows to query the - * value and divergence of - * (components of) shape functions - * and solutions representing - * tensors. The - * divergence of a tensor - * $T_{ij}, 0\le i,j<\text{dim}$ is - * defined as - * $d_i = \sum_j \frac{\partial T_{ji}}{\partial x_j}, - * 0\le i<\text{dim}$. + * This class allows to query the value and divergence of (components of) + * shape functions and solutions representing tensors. The divergence of a + * tensor $T_{ij}, 0\le i,j<\text{dim}$ is defined as $d_i = \sum_j + * \frac{\partial T_{ji}}{\partial x_j}, 0\le i<\text{dim}$. * - * You get an object of this type if you - * apply a - * FEValuesExtractors::Tensor to - * an FEValues, FEFaceValues or - * FESubfaceValues object. + * You get an object of this type if you apply a FEValuesExtractors::Tensor + * to an FEValues, FEFaceValues or FESubfaceValues object. * * @ingroup feaccess vector_valued * @@ -1260,8 +908,8 @@ namespace FEValuesViews public: /** - * Data type for what you get when you apply an extractor - * of this kind to a vector-valued finite element. + * Data type for what you get when you apply an extractor of this kind to + * a vector-valued finite element. */ typedef dealii::Tensor<2, spacedim> value_type; @@ -1271,88 +919,57 @@ namespace FEValuesViews typedef dealii::Tensor<1, spacedim> divergence_type; /** - * A structure where for each shape - * function we pre-compute a bunch of - * data that will make later accesses - * much cheaper. + * A structure where for each shape function we pre-compute a bunch of + * data that will make later accesses much cheaper. */ struct ShapeFunctionData { /** - * For each pair (shape - * function,component within - * vector), store whether the - * selected vector component may be - * nonzero. For primitive shape - * functions we know for sure - * whether a certain scalar - * component of a given shape - * function is nonzero, whereas for - * non-primitive shape functions - * this may not be entirely clear - * (e.g. for RT elements it depends - * on the shape of a cell). + * For each pair (shape function,component within vector), store whether + * the selected vector component may be nonzero. For primitive shape + * functions we know for sure whether a certain scalar component of a + * given shape function is nonzero, whereas for non-primitive shape + * functions this may not be entirely clear (e.g. for RT elements it + * depends on the shape of a cell). */ bool is_nonzero_shape_function_component[value_type::n_independent_components]; /** - * For each pair (shape function, - * component within vector), store - * the row index within the - * shape_values, shape_gradients, - * and shape_hessians tables (the - * column index is the quadrature - * point index). If the shape - * function is primitive, then we - * can get this information from - * the shape_function_to_row_table - * of the FEValues object; - * otherwise, we have to work a bit - * harder to compute this + * For each pair (shape function, component within vector), store the + * row index within the shape_values, shape_gradients, and + * shape_hessians tables (the column index is the quadrature point + * index). If the shape function is primitive, then we can get this + * information from the shape_function_to_row_table of the FEValues + * object; otherwise, we have to work a bit harder to compute this * information. */ unsigned int row_index[value_type::n_independent_components]; /** - * For each shape function say the - * following: if only a single - * entry in - * is_nonzero_shape_function_component - * for this shape function is - * nonzero, then store the - * corresponding value of row_index - * and - * single_nonzero_component_index - * represents the index between 0 - * and (dim^2) for which it is - * attained. If multiple components - * are nonzero, then store -1. If - * no components are nonzero then - * store -2. + * For each shape function say the following: if only a single entry in + * is_nonzero_shape_function_component for this shape function is + * nonzero, then store the corresponding value of row_index and + * single_nonzero_component_index represents the index between 0 and + * (dim^2) for which it is attained. If multiple components are nonzero, + * then store -1. If no components are nonzero then store -2. */ int single_nonzero_component; unsigned int single_nonzero_component_index; }; /** - * Default constructor. Creates an - * invalid object. + * Default constructor. Creates an invalid object. */ Tensor(); /** - * Constructor for an object that - * represents (dim*dim) - * components of a - * FEValuesBase object (or of one of - * the classes derived from - * FEValuesBase), representing the unique - * components comprising a second-order - * tensor valued variable. + * Constructor for an object that represents (dim*dim) + * components of a FEValuesBase object (or of one of the classes derived + * from FEValuesBase), representing the unique components comprising a + * second-order tensor valued variable. * - * The second argument denotes the - * index of the first component of the + * The second argument denotes the index of the first component of the * selected symmetric second order tensor. */ Tensor(const FEValuesBase &fe_values_base, @@ -1360,55 +977,39 @@ namespace FEValuesViews /** - * Copy operator. This is not a - * lightweight object so we don't allow - * copying and generate an exception if - * this function is called. + * Copy operator. This is not a lightweight object so we don't allow + * copying and generate an exception if this function is called. */ Tensor &operator=(const Tensor<2, dim, spacedim> &); /** - * Return the value of the vector - * components selected by this view, - * for the shape function and - * quadrature point selected by the - * arguments. Here, since the view - * represents a vector-valued part of - * the FEValues object with - * (dim*dim) components - * (the unique components of a second-order tensor), - * the return type is a tensor of rank 2. + * Return the value of the vector components selected by this view, for + * the shape function and quadrature point selected by the + * arguments. Here, since the view represents a vector-valued part of the + * FEValues object with (dim*dim) components (the unique + * components of a second-order tensor), the return type is a tensor of + * rank 2. * - * @param shape_function Number - * of the shape function to be - * evaluated. Note that this - * number runs from zero to - * dofs_per_cell, even in the - * case of an FEFaceValues or - * FESubfaceValues object. + * @param shape_function Number of the shape function to be + * evaluated. Note that this number runs from zero to dofs_per_cell, even + * in the case of an FEFaceValues or FESubfaceValues object. * - * @param q_point Number of - * the quadrature point at which - * function is to be evaluated + * @param q_point Number of the quadrature point at which function is to + * be evaluated */ value_type value (const unsigned int shape_function, const unsigned int q_point) const; /** - * Return the vector divergence of - * the vector components selected by - * this view, for the shape function - * and quadrature point selected by the + * Return the vector divergence of the vector components selected by this + * view, for the shape function and quadrature point selected by the * arguments. * - * See the general discussion - * of this class for a - * definition of the + * See the general discussion of this class for a definition of the * divergence. * - * @note The meaning of the arguments - * is as documented for the value() + * @note The meaning of the arguments is as documented for the value() * function. */ divergence_type @@ -1416,19 +1017,13 @@ namespace FEValuesViews const unsigned int q_point) const; /** - * Return the values of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the values of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * This function is the equivalent of - * the - * FEValuesBase::get_function_values - * function but it only works on the + * This function is the equivalent of the + * FEValuesBase::get_function_values function but it only works on the * selected vector components. */ template @@ -1437,26 +1032,17 @@ namespace FEValuesViews /** - * Return the divergence of the selected - * vector components of the finite - * element function characterized by - * fe_function at the - * quadrature points of the cell, face - * or subface selected the last time - * the reinit function of the - * FEValues object was called. + * Return the divergence of the selected vector components of the finite + * element function characterized by fe_function at the + * quadrature points of the cell, face or subface selected the last time + * the reinit function of the FEValues object was called. * - * There is no equivalent function such - * as - * FEValuesBase::get_function_divergences - * in the FEValues classes but the - * information can be obtained from - * FEValuesBase::get_function_gradients, + * There is no equivalent function such as + * FEValuesBase::get_function_divergences in the FEValues classes but the + * information can be obtained from FEValuesBase::get_function_gradients, * of course. * - * See the general discussion - * of this class for a - * definition of the + * See the general discussion of this class for a definition of the * divergence. */ template @@ -1465,21 +1051,18 @@ namespace FEValuesViews private: /** - * A reference to the FEValuesBase object - * we operate on. + * A reference to the FEValuesBase object we operate on. */ const FEValuesBase &fe_values; /** - * The first component of the vector - * this view represents of the + * The first component of the vector this view represents of the * FEValuesBase object. */ const unsigned int first_tensor_component; /** - * Store the data about shape - * functions. + * Store the data about shape functions. */ std::vector shape_function_data; }; @@ -1492,24 +1075,18 @@ namespace internal namespace FEValuesViews { /** - * A class objects of which store a - * collection of FEValuesViews::Scalar, - * FEValuesViews::Vector, etc object. The - * FEValuesBase class uses it to generate - * all possible Views classes upon - * construction time; we do this at - * construction time since the Views - * classes cache some information and are - * therefore relatively expensive to - * create. + * A class objects of which store a collection of FEValuesViews::Scalar, + * FEValuesViews::Vector, etc object. The FEValuesBase class uses it to + * generate all possible Views classes upon construction time; we do this + * at construction time since the Views classes cache some information and + * are therefore relatively expensive to create. */ template struct Cache { /** - * Caches for scalar and - * vector, and symmetric second-order - * tensor valued views. + * Caches for scalar and vector, and symmetric second-order tensor + * valued views. */ std::vector > scalars; std::vector > vectors; @@ -1532,16 +1109,15 @@ namespace internal //TODO: Several FEValuesBase of a system should share Mapping /** - * Contains all data vectors for FEValues. - * This class has been extracted from FEValuesBase to be handed - * over to the fill functions of Mapping and + * Contains all data vectors for FEValues. This class has been extracted from + * FEValuesBase to be handed over to the fill functions of Mapping and * FiniteElement. * - * @note All data fields are public, but this is not - * critical, because access to this object is private in FEValues. + * @note All data fields are public, but this is not critical, because access + * to this object is private in FEValues. * - * The purpose of this class is discussed - * on the page on @ref UpdateFlagsEssay. + * The purpose of this class is discussed on the page on @ref + * UpdateFlagsEssay. * * @ingroup feaccess * @author Guido Kanschat @@ -1552,179 +1128,118 @@ class FEValuesData { public: /** - * Initialize all vectors to - * correct size. + * Initialize all vectors to correct size. */ void initialize (const unsigned int n_quadrature_points, const FiniteElement &fe, const UpdateFlags flags); /** - * Storage type for shape - * values. Each row in the matrix - * denotes the values of a single - * shape function at the - * different points, columns are - * for a single point with the - * different shape functions. + * Storage type for shape values. Each row in the matrix denotes the values + * of a single shape function at the different points, columns are for a + * single point with the different shape functions. * - * If a shape function has more - * than one non-zero component - * (in deal.II diction: it is - * non-primitive), then we - * allocate one row per non-zero - * component, and shift - * subsequent rows backward. - * Lookup of the correct row for - * a shape function is thus - * simple in case the entire - * finite element is primitive - * (i.e. all shape functions are - * primitive), since then the - * shape function number equals - * the row number. Otherwise, use - * the - * #shape_function_to_row_table - * array to get at the first row - * that belongs to this - * particular shape function, and - * navigate among all the rows - * for this shape function using - * the - * FiniteElement::get_nonzero_components() - * function which tells us which - * components are non-zero and - * thus have a row in the array - * presently under discussion. + * If a shape function has more than one non-zero component (in deal.II + * diction: it is non-primitive), then we allocate one row per non-zero + * component, and shift subsequent rows backward. Lookup of the correct row + * for a shape function is thus simple in case the entire finite element is + * primitive (i.e. all shape functions are primitive), since then the shape + * function number equals the row number. Otherwise, use the + * #shape_function_to_row_table array to get at the first row that belongs + * to this particular shape function, and navigate among all the rows for + * this shape function using the FiniteElement::get_nonzero_components() + * function which tells us which components are non-zero and thus have a row + * in the array presently under discussion. */ typedef Table<2,double> ShapeVector; /** - * Storage type for - * gradients. The layout of data - * is the same as for the + * Storage type for gradients. The layout of data is the same as for the * #ShapeVector data type. */ typedef std::vector > > GradientVector; /** - * Likewise for second order - * derivatives. + * Likewise for second order derivatives. */ typedef std::vector > > HessianVector; /** - * Store the values of the shape - * functions at the quadrature - * points. See the description of - * the data type for the layout - * of the data in this field. + * Store the values of the shape functions at the quadrature points. See the + * description of the data type for the layout of the data in this field. */ ShapeVector shape_values; /** - * Store the gradients of the - * shape functions at the - * quadrature points. See the - * description of the data type - * for the layout of the data in - * this field. + * Store the gradients of the shape functions at the quadrature points. See + * the description of the data type for the layout of the data in this + * field. */ GradientVector shape_gradients; /** - * Store the 2nd derivatives of - * the shape functions at the - * quadrature points. See the - * description of the data type - * for the layout of the data in - * this field. + * Store the 2nd derivatives of the shape functions at the quadrature + * points. See the description of the data type for the layout of the data + * in this field. */ HessianVector shape_hessians; /** - * Store an array of weights - * times the Jacobi determinant - * at the quadrature points. This - * function is reset each time - * reinit() is called. The - * Jacobi determinant is actually - * the reciprocal value of the - * Jacobi matrices stored in this - * class, see the general - * documentation of this class - * for more information. + * Store an array of weights times the Jacobi determinant at the quadrature + * points. This function is reset each time reinit() is called. The Jacobi + * determinant is actually the reciprocal value of the Jacobi matrices + * stored in this class, see the general documentation of this class for + * more information. * - * However, if this object refers - * to an FEFaceValues or - * FESubfaceValues object, then - * the JxW_values correspond to - * the Jacobian of the - * transformation of the face, - * not the cell, i.e. the - * dimensionality is that of a - * surface measure, not of a - * volume measure. In this case, - * it is computed from the - * boundary forms, rather than - * the Jacobian matrix. + * However, if this object refers to an FEFaceValues or FESubfaceValues + * object, then the JxW_values correspond to the Jacobian of the + * transformation of the face, not the cell, i.e. the dimensionality is that + * of a surface measure, not of a volume measure. In this case, it is + * computed from the boundary forms, rather than the Jacobian matrix. */ std::vector JxW_values; /** - * Array of the Jacobian matrices at the - * quadrature points. + * Array of the Jacobian matrices at the quadrature points. */ std::vector< DerivativeForm<1,dim,spacedim> > jacobians; /** - * Array of the derivatives of the Jacobian - * matrices at the quadrature points. + * Array of the derivatives of the Jacobian matrices at the quadrature + * points. */ std::vector > jacobian_grads; /** - * Array of the inverse Jacobian matrices - * at the quadrature points. + * Array of the inverse Jacobian matrices at the quadrature points. */ std::vector > inverse_jacobians; /** - * Array of quadrature points. This array - * is set up upon calling reinit() and - * contains the quadrature points on the - * real element, rather than on the - * reference element. + * Array of quadrature points. This array is set up upon calling reinit() + * and contains the quadrature points on the real element, rather than on + * the reference element. */ std::vector > quadrature_points; /** - * List of outward normal vectors at the - * quadrature points. This field is filled - * in by the finite element class. + * List of outward normal vectors at the quadrature points. This field is + * filled in by the finite element class. */ std::vector > normal_vectors; /** - * List of boundary forms at the - * quadrature points. This field is filled - * in by the finite element class. + * List of boundary forms at the quadrature points. This field is filled in + * by the finite element class. */ std::vector > boundary_forms; /** - * When asked for the value (or - * gradient, or Hessian) of shape - * function i's c-th vector - * component, we need to look it - * up in the #shape_values, - * #shape_gradients and - * #shape_hessians arrays. The - * question is where in this - * array does the data for shape - * function i, component c - * reside. This is what this - * table answers. + * When asked for the value (or gradient, or Hessian) of shape function i's + * c-th vector component, we need to look it up in the #shape_values, + * #shape_gradients and #shape_hessians arrays. The question is where in + * this array does the data for shape function i, component c reside. This is + * what this table answers. * * The format of the table is as * follows: @@ -1740,43 +1255,24 @@ public: * corresponding datum is stored * for all the quadrature points. * - * In the general, vector-valued - * context, the number of - * components is larger than one, - * but for a given shape - * function, not all vector - * components may be nonzero - * (e.g., if a shape function is - * primitive, then exactly one - * vector component is non-zero, - * while the others are all - * zero). For such zero - * components, #shape_values and - * friends do not have a - * row. Consequently, for vector - * components for which shape - * function i is zero, the entry - * in the current table is - * numbers::invalid_unsigned_int. + * In the general, vector-valued context, the number of components is larger + * than one, but for a given shape function, not all vector components may be + * nonzero (e.g., if a shape function is primitive, then exactly one vector + * component is non-zero, while the others are all zero). For such zero + * components, #shape_values and friends do not have a row. Consequently, for + * vector components for which shape function i is zero, the entry in the + * current table is numbers::invalid_unsigned_int. * - * On the other hand, the table - * is guaranteed to have at least - * one valid index for each shape - * function. In particular, for a - * primitive finite element, each - * shape function has exactly one - * nonzero component and so for - * each i, there is exactly one - * valid index within the range - * [i*n_components, - * (i+1)*n_components). + * On the other hand, the table is guaranteed to have at least one valid + * index for each shape function. In particular, for a primitive finite + * element, each shape function has exactly one nonzero component and so for + * each i, there is exactly one valid index within the range + * [i*n_components, (i+1)*n_components). */ std::vector shape_function_to_row_table; /** - * Original update flags handed - * to the constructor of - * FEValues. + * Original update flags handed to the constructor of FEValues. */ UpdateFlags update_flags; }; @@ -1878,19 +1374,18 @@ public: * *

UpdateFlags

* - * The UpdateFlags object handed to the constructor is used to - * determine which of the data fields to compute. This way, it is - * possible to avoid expensive computations of useless derivatives. - * In the beginning, these flags are processed through the functions - * Mapping::update_once(), Mapping::update_each(), - * FiniteElement::update_once() FiniteElement::update_each(). All the - * results are bit-wise or'd and determine the fields actually - * computed. This enables Mapping and FiniteElement to schedule - * auxiliary data fields for updating. Still, it is recommended to - * give all needed update flags to FEValues. + * The UpdateFlags object handed to the constructor is used to determine which + * of the data fields to compute. This way, it is possible to avoid expensive + * computations of useless derivatives. In the beginning, these flags are + * processed through the functions Mapping::update_once(), + * Mapping::update_each(), FiniteElement::update_once() + * FiniteElement::update_each(). All the results are bit-wise or'd and + * determine the fields actually computed. This enables Mapping and + * FiniteElement to schedule auxiliary data fields for updating. Still, it is + * recommended to give all needed update flags to FEValues. * - * The mechanisms by which this class works is also discussed - * on the page on @ref UpdateFlagsEssay. + * The mechanisms by which this class works is also discussed on the page on + * @ref UpdateFlagsEssay. * * @ingroup feaccess * @author Wolfgang Bangerth, 1998, 2003, Guido Kanschat, 2001 @@ -1901,14 +1396,12 @@ class FEValuesBase : protected FEValuesData, { public: /** - * Dimension in which this object - * operates. + * Dimension in which this object operates. */ static const unsigned int dimension = dim; /** - * Dimension of the space in - * which this object operates. + * Dimension of the space in which this object operates. */ static const unsigned int space_dimension = spacedim; @@ -1918,30 +1411,19 @@ public: const unsigned int n_quadrature_points; /** - * Number of shape functions per - * cell. If we use this base - * class to evaluate a finite - * element on faces of cells, - * this is still the number of - * degrees of freedom per cell, - * not per face. + * Number of shape functions per cell. If we use this base class to evaluate + * a finite element on faces of cells, this is still the number of degrees + * of freedom per cell, not per face. */ const unsigned int dofs_per_cell; /** - * Constructor. Set up the array - * sizes with n_q_points - * quadrature points, dofs_per_cell - * trial functions per cell and - * with the given pattern to - * update the fields when the - * reinit function of the - * derived classes is called. The - * fields themselves are not set - * up, this must happen in the - * constructor of the derived - * class. + * Constructor. Set up the array sizes with n_q_points quadrature + * points, dofs_per_cell trial functions per cell and with the + * given pattern to update the fields when the reinit function of + * the derived classes is called. The fields themselves are not set up, this + * must happen in the constructor of the derived class. */ FEValuesBase (const unsigned int n_q_points, const unsigned int dofs_per_cell, @@ -1958,71 +1440,42 @@ public: //@{ /** - * Value of a shape function at a - * quadrature point on the cell, - * face or subface selected the - * last time the reinit - * function of the derived class - * was called. + * Value of a shape function at a quadrature point on the cell, face or + * subface selected the last time the reinit function of the + * derived class was called. * - * If the shape function is - * vector-valued, then this - * returns the only non-zero - * component. If the shape - * function has more than one - * non-zero component (i.e. it is - * not primitive), then throw an - * exception of type - * ExcShapeFunctionNotPrimitive. In - * that case, use the - * shape_value_component() - * function. + * If the shape function is vector-valued, then this returns the only + * non-zero component. If the shape function has more than one non-zero + * component (i.e. it is not primitive), then throw an exception of type + * ExcShapeFunctionNotPrimitive. In that case, use the + * shape_value_component() function. * - * @param function_no Number - * of the shape function to be - * evaluated. Note that this - * number runs from zero to - * dofs_per_cell, even in the - * case of an FEFaceValues or - * FESubfaceValues object. + * @param function_no Number of the shape function to be evaluated. Note + * that this number runs from zero to dofs_per_cell, even in the case of an + * FEFaceValues or FESubfaceValues object. * - * @param point_no Number of - * the quadrature point at which - * function is to be evaluated + * @param point_no Number of the quadrature point at which function is to be + * evaluated */ const double &shape_value (const unsigned int function_no, const unsigned int point_no) const; /** - * Compute one vector component of - * the value of a shape function - * at a quadrature point. If the - * finite element is scalar, then - * only component zero is allowed - * and the return value equals - * that of the shape_value() - * function. If the finite - * element is vector valued but - * all shape functions are - * primitive (i.e. they are - * non-zero in only one - * component), then the value - * returned by shape_value() - * equals that of this function - * for exactly one - * component. This function is - * therefore only of greater - * interest if the shape function - * is not primitive, but then it - * is necessary since the other + * Compute one vector component of the value of a shape function at a + * quadrature point. If the finite element is scalar, then only component + * zero is allowed and the return value equals that of the shape_value() + * function. If the finite element is vector valued but all shape functions + * are primitive (i.e. they are non-zero in only one component), then the + * value returned by shape_value() equals that of this function for exactly + * one component. This function is therefore only of greater interest if the + * shape function is not primitive, but then it is necessary since the other * function cannot be used. * - * @param function_no Number - * of the shape function to be + * @param function_no Number of the shape function to be evaluated + * + * @param point_no Number of the quadrature point at which function is to be * evaluated - * @param point_no Number of - * the quadrature point at which - * function is to be evaluated + * * @param component vector component to be evaluated */ double shape_value_component (const unsigned int function_no, @@ -2030,37 +1483,21 @@ public: const unsigned int component) const; /** - * Compute the gradient of the - * function_noth shape function at the - * quadrature_pointth quadrature point with - * respect to real cell - * coordinates. If you want to - * get the derivative in one of - * the coordinate directions, use - * the appropriate function of - * the Tensor class to - * extract one component of the Tensor returned by this - * function. Since - * only a reference to the - * gradient's value is returned, - * there should be no major + * Compute the gradient of the function_noth shape function at the + * quadrature_pointth quadrature point with respect to real cell + * coordinates. If you want to get the derivative in one of the coordinate + * directions, use the appropriate function of the Tensor class to extract + * one component of the Tensor returned by this function. Since only a + * reference to the gradient's value is returned, there should be no major * performance drawback. * - * If the shape function is - * vector-valued, then this - * returns the only non-zero - * component. If the shape - * function has more than one - * non-zero component (i.e. it is - * not primitive), then it will throw an - * exception of type - * ExcShapeFunctionNotPrimitive. In - * that case, use the - * shape_grad_component() - * function. + * If the shape function is vector-valued, then this returns the only + * non-zero component. If the shape function has more than one non-zero + * component (i.e. it is not primitive), then it will throw an exception of + * type ExcShapeFunctionNotPrimitive. In that case, use the + * shape_grad_component() function. * - * The same holds for the arguments - * of this function as for the + * The same holds for the arguments of this function as for the * shape_value() function. */ const Tensor<1,spacedim> & @@ -2068,31 +1505,17 @@ public: const unsigned int quadrature_point) const; /** - * Return one vector component of - * the gradient of a shape function - * at a quadrature point. If the - * finite element is scalar, then - * only component zero is allowed - * and the return value equals - * that of the shape_grad() - * function. If the finite - * element is vector valued but - * all shape functions are - * primitive (i.e. they are - * non-zero in only one - * component), then the value - * returned by shape_grad() - * equals that of this function - * for exactly one - * component. This function is - * therefore only of greater - * interest if the shape function - * is not primitive, but then it - * is necessary since the other + * Return one vector component of the gradient of a shape function at a + * quadrature point. If the finite element is scalar, then only component + * zero is allowed and the return value equals that of the shape_grad() + * function. If the finite element is vector valued but all shape functions + * are primitive (i.e. they are non-zero in only one component), then the + * value returned by shape_grad() equals that of this function for exactly + * one component. This function is therefore only of greater interest if the + * shape function is not primitive, but then it is necessary since the other * function cannot be used. * - * The same holds for the arguments - * of this function as for the + * The same holds for the arguments of this function as for the * shape_value_component() function. */ Tensor<1,spacedim> @@ -2101,36 +1524,20 @@ public: const unsigned int component) const; /** - * Second derivatives of - * the function_noth shape function at - * the point_noth quadrature point - * with respect to real cell - * coordinates. If you want to - * get the derivatives in one of - * the coordinate directions, use - * the appropriate function of - * the Tensor class to - * extract one component. Since - * only a reference to the - * derivative values is returned, - * there should be no major - * performance drawback. + * Second derivatives of the function_noth shape function at the + * point_noth quadrature point with respect to real cell + * coordinates. If you want to get the derivatives in one of the coordinate + * directions, use the appropriate function of the Tensor class to extract + * one component. Since only a reference to the derivative values is + * returned, there should be no major performance drawback. * - * If the shape function is - * vector-valued, then this - * returns the only non-zero - * component. If the shape - * function has more than one - * non-zero component (i.e. it is - * not primitive), then throw an - * exception of type - * ExcShapeFunctionNotPrimitive. In - * that case, use the - * shape_grad_grad_component() - * function. + * If the shape function is vector-valued, then this returns the only + * non-zero component. If the shape function has more than one non-zero + * component (i.e. it is not primitive), then throw an exception of type + * ExcShapeFunctionNotPrimitive. In that case, use the + * shape_grad_grad_component() function. * - * The same holds for the arguments - * of this function as for the + * The same holds for the arguments of this function as for the * shape_value() function. */ const Tensor<2,spacedim> & @@ -2146,33 +1553,17 @@ public: /** - * Return one vector component of - * the gradient of a shape - * function at a quadrature - * point. If the finite element - * is scalar, then only component - * zero is allowed and the return - * value equals that of the - * shape_hessian() - * function. If the finite - * element is vector valued but - * all shape functions are - * primitive (i.e. they are - * non-zero in only one - * component), then the value - * returned by - * shape_hessian() - * equals that of this function - * for exactly one - * component. This function is - * therefore only of greater - * interest if the shape function - * is not primitive, but then it - * is necessary since the other - * function cannot be used. + * Return one vector component of the gradient of a shape function at a + * quadrature point. If the finite element is scalar, then only component + * zero is allowed and the return value equals that of the shape_hessian() + * function. If the finite element is vector valued but all shape functions + * are primitive (i.e. they are non-zero in only one component), then the + * value returned by shape_hessian() equals that of this function for + * exactly one component. This function is therefore only of greater + * interest if the shape function is not primitive, but then it is necessary + * since the other function cannot be used. * - * The same holds for the arguments - * of this function as for the + * The same holds for the arguments of this function as for the * shape_value_component() function. */ Tensor<2,spacedim> @@ -2194,131 +1585,71 @@ public: //@{ /** - * Returns the values of a finite - * element function restricted to - * the current cell, face or - * subface selected the last time - * the reinit function - * of the derived class was - * called, at the quadrature - * points. + * Returns the values of a finite element function restricted to the current + * cell, face or subface selected the last time the reinit function + * of the derived class was called, at the quadrature points. * - * If the present cell is not - * active then values are - * interpolated to the current - * cell and point values are - * computed from that. + * If the present cell is not active then values are interpolated to the + * current cell and point values are computed from that. * - * This function may only be used - * if the finite element in use - * is a scalar one, i.e. has only - * one vector component. To get - * values of multi-component - * elements, there is another - * get_function_values() below, - * returning a vector of vectors - * of results. + * This function may only be used if the finite element in use is a scalar + * one, i.e. has only one vector component. To get values of + * multi-component elements, there is another get_function_values() below, + * returning a vector of vectors of results. * - * @param[in] fe_function A - * vector of values that - * describes (globally) the - * finite element function that - * this function should evaluate - * at the quadrature points of - * the current cell. + * @param[in] fe_function A vector of values that describes (globally) the + * finite element function that this function should evaluate at the + * quadrature points of the current cell. * - * @param[out] values The values - * of the function specified by - * fe_function at the quadrature - * points of the current cell. - * The object is assume to + * @param[out] values The values of the function specified by fe_function at + * the quadrature points of the current cell. The object is assume to * already have the correct size. * - * @post values[q] - * will contain the value of the - * field described by fe_function - * at the $q$th quadrature point. + * @post values[q] will contain the value of the field + * described by fe_function at the $q$th quadrature point. * - * @note The actual data type of the - * input vector may be either a - * Vector<T>, - * BlockVector<T>, or one - * of the sequential PETSc or - * Trilinos vector wrapper - * classes. It represents a - * global vector of DoF values - * associated with the DofHandler - * object with which this - * FEValues object was last - * initialized. Alternatively, - * if the vector argument is of - * type IndexSet, then the function - * is represented as one that - * is either zero or one, depending - * on whether a DoF index is in - * the set or not. + * @note The actual data type of the input vector may be either a + * Vector<T>, BlockVector<T>, or one of the sequential PETSc or + * Trilinos vector wrapper classes. It represents a global vector of DoF + * values associated with the DofHandler object with which this FEValues + * object was last initialized. Alternatively, if the vector argument is of + * type IndexSet, then the function is represented as one that is either + * zero or one, depending on whether a DoF index is in the set or not. */ template void get_function_values (const InputVector &fe_function, std::vector &values) const; /** - * This function does the same as - * the other - * get_function_values(), but - * applied to multi-component - * (vector-valued) elements. The - * meaning of the arguments is as - * explained there. + * This function does the same as the other get_function_values(), but + * applied to multi-component (vector-valued) elements. The meaning of the + * arguments is as explained there. * - * @post values[q] - * is a vector of values of the - * field described by fe_function - * at the $q$th quadrature - * point. The size of the vector - * accessed by - * values[q] equals - * the number of components of - * the finite element, - * i.e. values[q](c) - * returns the value of the $c$th - * vector component at the $q$th - * quadrature point. + * @post values[q] is a vector of values of the field described + * by fe_function at the $q$th quadrature point. The size of the vector + * accessed by values[q] equals the number of components of the + * finite element, i.e. values[q](c) returns the value of the + * $c$th vector component at the $q$th quadrature point. */ template void get_function_values (const InputVector &fe_function, std::vector > &values) const; /** - * Generate function values from - * an arbitrary vector. + * Generate function values from an arbitrary vector. * - * This function offers the - * possibility to extract - * function values in quadrature - * points from vectors not - * corresponding to a whole + * This function offers the possibility to extract function values in + * quadrature points from vectors not corresponding to a whole * discretization. * - * The vector indices - * corresponds to the degrees of - * freedom on a single cell. Its - * length may even be a multiple - * of the number of dofs per - * cell. Then, the vectors in - * value should allow - * for the same multiple of the - * components of the finite - * element. + * The vector indices corresponds to the degrees of freedom on a + * single cell. Its length may even be a multiple of the number of dofs per + * cell. Then, the vectors in value should allow for the same + * multiple of the components of the finite element. * - * You may want to use this - * function, if you want to - * access just a single block - * from a BlockVector, if you - * have a multi-level vector or - * if you already have a local - * representation of your finite - * element data. + * You may want to use this function, if you want to access just a single + * block from a BlockVector, if you have a multi-level vector or if you + * already have a local representation of your finite element data. */ template void get_function_values (const InputVector &fe_function, @@ -2326,42 +1657,23 @@ public: std::vector &values) const; /** - * Generate vector function - * values from an arbitrary - * vector. + * Generate vector function values from an arbitrary vector. * - * This function offers the - * possibility to extract - * function values in quadrature - * points from vectors not - * corresponding to a whole + * This function offers the possibility to extract function values in + * quadrature points from vectors not corresponding to a whole * discretization. * - * The vector indices - * corresponds to the degrees of - * freedom on a single cell. Its - * length may even be a multiple - * of the number of dofs per - * cell. Then, the vectors in - * value should allow - * for the same multiple of the - * components of the finite - * element. + * The vector indices corresponds to the degrees of freedom on a + * single cell. Its length may even be a multiple of the number of dofs per + * cell. Then, the vectors in value should allow for the same + * multiple of the components of the finite element. * - * You may want to use this - * function, if you want to - * access just a single block - * from a BlockVector, if you - * have a multi-level vector or - * if you already have a local - * representation of your finite - * element data. + * You may want to use this function, if you want to access just a single + * block from a BlockVector, if you have a multi-level vector or if you + * already have a local representation of your finite element data. * - * Since this function allows for - * fairly general combinations of - * argument sizes, be aware that - * the checks on the arguments - * may not detect errors. + * Since this function allows for fairly general combinations of argument + * sizes, be aware that the checks on the arguments may not detect errors. */ template void get_function_values (const InputVector &fe_function, @@ -2370,62 +1682,32 @@ public: /** - * Generate vector function - * values from an arbitrary - * vector. + * Generate vector function values from an arbitrary vector. * - * This function offers the - * possibility to extract - * function values in quadrature - * points from vectors not - * corresponding to a whole + * This function offers the possibility to extract function values in + * quadrature points from vectors not corresponding to a whole * discretization. * - * The vector indices - * corresponds to the degrees of - * freedom on a single cell. Its - * length may even be a multiple - * of the number of dofs per - * cell. Then, the vectors in - * value should allow - * for the same multiple of the - * components of the finite - * element. + * The vector indices corresponds to the degrees of freedom on a + * single cell. Its length may even be a multiple of the number of dofs per + * cell. Then, the vectors in value should allow for the same + * multiple of the components of the finite element. * - * Depending on the value of the last - * argument, the outer vector of - * values has either the - * length of the quadrature rule - * (quadrature_points_fastest - * == false) or the length - * of components to be filled - * quadrature_points_fastest - * == true. If p is - * the current quadrature point - * number and i is the - * vector component of the - * solution desired, the access - * to values is - * values[p][i] if - * quadrature_points_fastest - * == false, and - * values[i][p] - * otherwise. + * Depending on the value of the last argument, the outer vector of + * values has either the length of the quadrature rule + * (quadrature_points_fastest == false) or the length of components + * to be filled quadrature_points_fastest == true. If p is + * the current quadrature point number and i is the vector + * component of the solution desired, the access to values is + * values[p][i] if quadrature_points_fastest == false, and + * values[i][p] otherwise. * - * You may want to use this - * function, if you want to - * access just a single block - * from a BlockVector, if you - * have a multi-level vector or - * if you already have a local - * representation of your finite - * element data. + * You may want to use this function, if you want to access just a single + * block from a BlockVector, if you have a multi-level vector or if you + * already have a local representation of your finite element data. * - * Since this function allows for - * fairly general combinations of - * argument sizes, be aware that - * the checks on the arguments - * may not detect errors. + * Since this function allows for fairly general combinations of argument + * sizes, be aware that the checks on the arguments may not detect errors. */ template void get_function_values (const InputVector &fe_function, @@ -2438,118 +1720,62 @@ public: //@{ /** - * Compute the gradients of a - * finite element at the - * quadrature points of a - * cell. This function is the - * equivalent of the - * corresponding - * get_function_values() function - * (see there for more - * information) but evaluates the - * finite element field's - * gradient instead of its value. + * Compute the gradients of a finite element at the quadrature points of a + * cell. This function is the equivalent of the corresponding + * get_function_values() function (see there for more information) but + * evaluates the finite element field's gradient instead of its value. * - * This function may only be used - * if the finite element in use - * is a scalar one, i.e. has only - * one vector component. There is - * a corresponding function of - * the same name for - * vector-valued finite elements. + * This function may only be used if the finite element in use is a scalar + * one, i.e. has only one vector component. There is a corresponding + * function of the same name for vector-valued finite elements. * - * @param[in] fe_function A - * vector of values that - * describes (globally) the - * finite element function that - * this function should evaluate - * at the quadrature points of - * the current cell. + * @param[in] fe_function A vector of values that describes (globally) the + * finite element function that this function should evaluate at the + * quadrature points of the current cell. * - * @param[out] gradients The gradients - * of the function specified by - * fe_function at the quadrature - * points of the current cell. - * The gradients are computed - * in real space (as opposed to - * on the unit cell). - * The object is assume to - * already have the correct size. + * @param[out] gradients The gradients of the function specified by + * fe_function at the quadrature points of the current cell. The gradients + * are computed in real space (as opposed to on the unit cell). The object + * is assume to already have the correct size. * - * @post - * gradients[q] will - * contain the gradient of the - * field described by fe_function - * at the $q$th quadrature - * point. gradients[q][d] - * represents the derivative in - * coordinate direction $d$ at - * quadrature point $q$. + * @post gradients[q] will contain the gradient of the field + * described by fe_function at the $q$th quadrature + * point. gradients[q][d] represents the derivative in + * coordinate direction $d$ at quadrature point $q$. * - * @note The actual data type of the - * input vector may be either a - * Vector<T>, - * BlockVector<T>, or one - * of the sequential PETSc or - * Trilinos vector wrapper - * classes. It represents a - * global vector of DoF values - * associated with the DofHandler - * object with which this - * FEValues object was last - * initialized. Alternatively, - * if the vector argument is of - * type IndexSet, then the function - * is represented as one that - * is either zero or one, depending - * on whether a DoF index is in - * the set or not. + * @note The actual data type of the input vector may be either a + * Vector<T>, BlockVector<T>, or one of the sequential PETSc or + * Trilinos vector wrapper classes. It represents a global vector of DoF + * values associated with the DofHandler object with which this FEValues + * object was last initialized. Alternatively, if the vector argument is of + * type IndexSet, then the function is represented as one that is either + * zero or one, depending on whether a DoF index is in the set or not. */ template void get_function_gradients (const InputVector &fe_function, std::vector > &gradients) const; /** - * This function does the same as - * the other - * get_function_gradients(), but - * applied to multi-component - * (vector-valued) elements. The - * meaning of the arguments is as - * explained there. + * This function does the same as the other get_function_gradients(), but + * applied to multi-component (vector-valued) elements. The meaning of the + * arguments is as explained there. * - * @post - * gradients[q] is a - * vector of gradients of the - * field described by fe_function - * at the $q$th quadrature - * point. The size of the vector - * accessed by - * gradients[q] - * equals the number of - * components of the finite - * element, - * i.e. gradients[q][c] - * returns the gradient of the - * $c$th vector component at the - * $q$th quadrature - * point. Consequently, - * gradients[q][c][d] - * is the derivative in - * coordinate direction $d$ of - * the $c$th vector component of - * the vector field at quadrature - * point $q$ of the current cell. + * @post gradients[q] is a vector of gradients of the field + * described by fe_function at the $q$th quadrature point. The size of the + * vector accessed by gradients[q] equals the number of + * components of the finite element, i.e. gradients[q][c] + * returns the gradient of the $c$th vector component at the $q$th + * quadrature point. Consequently, gradients[q][c][d] is the + * derivative in coordinate direction $d$ of the $c$th vector component of + * the vector field at quadrature point $q$ of the current cell. */ template void get_function_gradients (const InputVector &fe_function, std::vector > > &gradients) const; /** - * Function gradient access with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Function gradient access with more flexibility. see get_function_values() + * with corresponding arguments. */ template void get_function_gradients (const InputVector &fe_function, @@ -2557,10 +1783,8 @@ public: std::vector > &gradients) const; /** - * Function gradient access with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Function gradient access with more flexibility. see get_function_values() + * with corresponding arguments. */ template void get_function_gradients (const InputVector &fe_function, @@ -2569,24 +1793,21 @@ public: bool quadrature_points_fastest = false) const; /** - * @deprecated Use - * get_function_gradients() instead. + * @deprecated Use get_function_gradients() instead. */ template void get_function_grads (const InputVector &fe_function, std::vector > &gradients) const DEAL_II_DEPRECATED; /** - * @deprecated Use - * get_function_gradients() instead. + * @deprecated Use get_function_gradients() instead. */ template void get_function_grads (const InputVector &fe_function, std::vector > > &gradients) const DEAL_II_DEPRECATED; /** - * @deprecated Use - * get_function_gradients() instead. + * @deprecated Use get_function_gradients() instead. */ template void get_function_grads (const InputVector &fe_function, @@ -2594,8 +1815,7 @@ public: std::vector > &gradients) const DEAL_II_DEPRECATED; /** - * @deprecated Use - * get_function_gradients() instead. + * @deprecated Use get_function_gradients() instead. */ template void get_function_grads (const InputVector &fe_function, @@ -2608,74 +1828,37 @@ public: //@{ /** - * Compute the tensor of second - * derivatives of a finite - * element at the quadrature - * points of a cell. This - * function is the equivalent of - * the corresponding - * get_function_values() function - * (see there for more - * information) but evaluates the - * finite element field's second - * derivatives instead of its - * value. + * Compute the tensor of second derivatives of a finite element at the + * quadrature points of a cell. This function is the equivalent of the + * corresponding get_function_values() function (see there for more + * information) but evaluates the finite element field's second derivatives + * instead of its value. * - * This function may only be used - * if the finite element in use - * is a scalar one, i.e. has only - * one vector component. There is - * a corresponding function of - * the same name for - * vector-valued finite elements. + * This function may only be used if the finite element in use is a scalar + * one, i.e. has only one vector component. There is a corresponding + * function of the same name for vector-valued finite elements. * - * @param[in] fe_function A - * vector of values that - * describes (globally) the - * finite element function that - * this function should evaluate - * at the quadrature points of - * the current cell. + * @param[in] fe_function A vector of values that describes (globally) the + * finite element function that this function should evaluate at the + * quadrature points of the current cell. * - * @param[out] hessians The Hessians - * of the function specified by - * fe_function at the quadrature - * points of the current cell. - * The Hessians are computed - * in real space (as opposed to - * on the unit cell). - * The object is assume to - * already have the correct size. + * @param[out] hessians The Hessians of the function specified by + * fe_function at the quadrature points of the current cell. The Hessians + * are computed in real space (as opposed to on the unit cell). The object + * is assume to already have the correct size. * - * @post hessians[q] - * will contain the Hessian of - * the field described by - * fe_function at the $q$th - * quadrature - * point. gradients[q][i][j] - * represents the $(i,j)$th - * component of the matrix of - * second derivatives at - * quadrature point $q$. + * @post hessians[q] will contain the Hessian of the field + * described by fe_function at the $q$th quadrature + * point. gradients[q][i][j] represents the $(i,j)$th component + * of the matrix of second derivatives at quadrature point $q$. * - * @note The actual data type of the - * input vector may be either a - * Vector<T>, - * BlockVector<T>, or one - * of the sequential PETSc or - * Trilinos vector wrapper - * classes. It represents a - * global vector of DoF values - * associated with the DofHandler - * object with which this - * FEValues object was last - * initialized. Alternatively, - * if the vector argument is of - * type IndexSet, then the function - * is represented as one that - * is either zero or one, depending - * on whether a DoF index is in - * the set or not. + * @note The actual data type of the input vector may be either a + * Vector<T>, BlockVector<T>, or one of the sequential PETSc or + * Trilinos vector wrapper classes. It represents a global vector of DoF + * values associated with the DofHandler object with which this FEValues + * object was last initialized. Alternatively, if the vector argument is of + * type IndexSet, then the function is represented as one that is either + * zero or one, depending on whether a DoF index is in the set or not. */ template void @@ -2683,36 +1866,19 @@ public: std::vector > &hessians) const; /** - * This function does the same as - * the other - * get_function_hessians(), but - * applied to multi-component - * (vector-valued) elements. The - * meaning of the arguments is as - * explained there. + * This function does the same as the other get_function_hessians(), but + * applied to multi-component (vector-valued) elements. The meaning of the + * arguments is as explained there. * - * @post hessians[q] - * is a vector of Hessians of the - * field described by fe_function - * at the $q$th quadrature - * point. The size of the vector - * accessed by - * hessians[q] - * equals the number of - * components of the finite - * element, - * i.e. hessians[q][c] - * returns the Hessian of the - * $c$th vector component at the - * $q$th quadrature - * point. Consequently, - * values[q][c][i][j] - * is the $(i,j)$th component of - * the matrix of second - * derivatives of the $c$th - * vector component of the vector - * field at quadrature point $q$ - * of the current cell. + * @post hessians[q] is a vector of Hessians of the field + * described by fe_function at the $q$th quadrature point. The size of the + * vector accessed by hessians[q] equals the number of + * components of the finite element, i.e. hessians[q][c] + * returns the Hessian of the $c$th vector component at the $q$th quadrature + * point. Consequently, values[q][c][i][j] is the $(i,j)$th + * component of the matrix of second derivatives of the $c$th vector + * component of the vector field at quadrature point $q$ of the current + * cell. */ template void @@ -2721,11 +1887,8 @@ public: bool quadrature_points_fastest = false) const; /** - * Access to the second - * derivatives of a function with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Access to the second derivatives of a function with more flexibility. see + * get_function_values() with corresponding arguments. */ template void get_function_hessians ( @@ -2734,11 +1897,8 @@ public: std::vector > &hessians) const; /** - * Access to the second - * derivatives of a function with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Access to the second derivatives of a function with more flexibility. see + * get_function_values() with corresponding arguments. */ template void get_function_hessians ( @@ -2766,81 +1926,40 @@ public: /** * Compute the (scalar) Laplacian (i.e. the trace of the tensor of second - * derivatives) of a finite - * element at the quadrature - * points of a cell. This - * function is the equivalent of - * the corresponding - * get_function_values() function - * (see there for more - * information) but evaluates the - * finite element field's second - * derivatives instead of its - * value. + * derivatives) of a finite element at the quadrature points of a cell. This + * function is the equivalent of the corresponding get_function_values() + * function (see there for more information) but evaluates the finite + * element field's second derivatives instead of its value. * - * This function may only be used - * if the finite element in use - * is a scalar one, i.e. has only - * one vector component. There is - * a corresponding function of - * the same name for - * vector-valued finite elements. + * This function may only be used if the finite element in use is a scalar + * one, i.e. has only one vector component. There is a corresponding + * function of the same name for vector-valued finite elements. * - * @param[in] fe_function A - * vector of values that - * describes (globally) the - * finite element function that - * this function should evaluate - * at the quadrature points of - * the current cell. + * @param[in] fe_function A vector of values that describes (globally) the + * finite element function that this function should evaluate at the + * quadrature points of the current cell. * - * @param[out] laplacians The Laplacians - * of the function specified by - * fe_function at the quadrature - * points of the current cell. - * The Laplacians are computed - * in real space (as opposed to - * on the unit cell). - * The object is assume to - * already have the correct size. + * @param[out] laplacians The Laplacians of the function specified by + * fe_function at the quadrature points of the current cell. The Laplacians + * are computed in real space (as opposed to on the unit cell). The object + * is assume to already have the correct size. * - * @post laplacians[q] - * will contain the Laplacian of - * the field described by - * fe_function at the $q$th - * quadrature - * point. gradients[q][i][j] - * represents the $(i,j)$th - * component of the matrix of - * second derivatives at - * quadrature point $q$. + * @post laplacians[q] will contain the Laplacian of the field + * described by fe_function at the $q$th quadrature + * point. gradients[q][i][j] represents the $(i,j)$th component + * of the matrix of second derivatives at quadrature point $q$. * - * @post For each component of - * the output vector, there holds - * laplacians[q]=trace(hessians[q]), - * where hessians would - * be the output of the - * get_function_hessians() - * function. + * @post For each component of the output vector, there holds + * laplacians[q]=trace(hessians[q]), where hessians + * would be the output of the get_function_hessians() function. * - * @note The actual data type of the - * input vector may be either a - * Vector<T>, - * BlockVector<T>, or one - * of the sequential PETSc or - * Trilinos vector wrapper - * classes. It represents a - * global vector of DoF values - * associated with the DofHandler - * object with which this - * FEValues object was last - * initialized. Alternatively, - * if the vector argument is of - * type IndexSet, then the function - * is represented as one that - * is either zero or one, depending - * on whether a DoF index is in - * the set or not. + * @note The actual data type of the input vector may be either a + * Vector<T>, BlockVector<T>, or one of the sequential PETSc or + * Trilinos vector wrapper classes. It represents a global vector of DoF + * values associated with the DofHandler object with which this FEValues + * object was last initialized. Alternatively, if the vector argument is of + * type IndexSet, then the function is represented as one that is either + * zero or one, depending on whether a DoF index is in the set or not. */ template void @@ -2848,36 +1967,20 @@ public: std::vector &laplacians) const; /** - * This function does the same as - * the other - * get_function_laplacians(), but - * applied to multi-component - * (vector-valued) elements. The - * meaning of the arguments is as - * explained there. + * This function does the same as the other get_function_laplacians(), but + * applied to multi-component (vector-valued) elements. The meaning of the + * arguments is as explained there. * - * @post laplacians[q] - * is a vector of Laplacians of the - * field described by fe_function - * at the $q$th quadrature - * point. The size of the vector - * accessed by - * laplacians[q] - * equals the number of - * components of the finite - * element, - * i.e. laplacians[q][c] - * returns the Laplacian of the - * $c$th vector component at the - * $q$th quadrature - * point. + * @post laplacians[q] is a vector of Laplacians of the field + * described by fe_function at the $q$th quadrature point. The size of the + * vector accessed by laplacians[q] equals the number of + * components of the finite element, i.e. laplacians[q][c] + * returns the Laplacian of the $c$th vector component at the $q$th + * quadrature point. * - * @post For each component of - * the output vector, there holds - * laplacians[q][c]=trace(hessians[q][c]), - * where hessians would - * be the output of the - * get_function_hessians() + * @post For each component of the output vector, there holds + * laplacians[q][c]=trace(hessians[q][c]), where + * hessians would be the output of the get_function_hessians() * function. */ template @@ -2886,11 +1989,8 @@ public: std::vector > &laplacians) const; /** - * Access to the second - * derivatives of a function with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Access to the second derivatives of a function with more flexibility. see + * get_function_values() with corresponding arguments. */ template void get_function_laplacians ( @@ -2899,11 +1999,8 @@ public: std::vector &laplacians) const; /** - * Access to the second - * derivatives of a function with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Access to the second derivatives of a function with more flexibility. see + * get_function_values() with corresponding arguments. */ template void get_function_laplacians ( @@ -2912,11 +2009,8 @@ public: std::vector > &laplacians) const; /** - * Access to the second - * derivatives of a function with - * more flexibility. see - * get_function_values() with - * corresponding arguments. + * Access to the second derivatives of a function with more flexibility. see + * get_function_values() with corresponding arguments. */ template void get_function_laplacians ( @@ -2930,149 +2024,106 @@ public: //@{ /** - * Position of the ith - * quadrature point in real space. + * Position of the ith quadrature point in real space. */ const Point &quadrature_point (const unsigned int i) const; /** - * Return a pointer to the vector of - * quadrature points in real space. + * Return a pointer to the vector of quadrature points in real space. */ const std::vector > &get_quadrature_points () const; /** - * Mapped quadrature weight. If - * this object refers to a volume - * evaluation (i.e. the derived - * class is of type FEValues), - * then this is the Jacobi - * determinant times the weight - * of the *ith unit - * quadrature point. + * Mapped quadrature weight. If this object refers to a volume evaluation + * (i.e. the derived class is of type FEValues), then this is the Jacobi + * determinant times the weight of the *ith unit quadrature point. * - * For surface evaluations - * (i.e. classes FEFaceValues or - * FESubfaceValues), it is the - * mapped surface element times - * the weight of the quadrature + * For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues), + * it is the mapped surface element times the weight of the quadrature * point. * - * You can think of the quantity returned - * by this function as the volume or - * surface element $dx, ds$ in the - * integral that we implement here by + * You can think of the quantity returned by this function as the volume or + * surface element $dx, ds$ in the integral that we implement here by * quadrature. */ double JxW (const unsigned int quadrature_point) const; /** - * Pointer to the array holding - * the values returned by JxW(). + * Pointer to the array holding the values returned by JxW(). */ const std::vector &get_JxW_values () const; /** - * Return the Jacobian of the - * transformation at the specified - * quadrature point, i.e. - * $J_{ij}=dx_i/d\hat x_j$ + * Return the Jacobian of the transformation at the specified quadrature + * point, i.e. $J_{ij}=dx_i/d\hat x_j$ */ const DerivativeForm<1,dim,spacedim> &jacobian (const unsigned int quadrature_point) const; /** - * Pointer to the array holding - * the values returned by jacobian(). + * Pointer to the array holding the values returned by jacobian(). */ const std::vector > &get_jacobians () const; /** - * Return the second derivative of the - * transformation from unit to real cell, - * i.e. the first derivative of the - * Jacobian, at the specified quadrature - * point, i.e. $G_{ijk}=dJ_{jk}/d\hat x_i$. + * Return the second derivative of the transformation from unit to real + * cell, i.e. the first derivative of the Jacobian, at the specified + * quadrature point, i.e. $G_{ijk}=dJ_{jk}/d\hat x_i$. */ const DerivativeForm<2,dim,spacedim> &jacobian_grad (const unsigned int quadrature_point) const; /** - * Pointer to the array holding - * the values returned by - * jacobian_grads(). + * Pointer to the array holding the values returned by jacobian_grads(). */ const std::vector > &get_jacobian_grads () const; /** - * Return the inverse Jacobian of the - * transformation at the specified - * quadrature point, i.e. - * $J_{ij}=d\hat x_i/dx_j$ + * Return the inverse Jacobian of the transformation at the specified + * quadrature point, i.e. $J_{ij}=d\hat x_i/dx_j$ */ const DerivativeForm<1,spacedim,dim> &inverse_jacobian (const unsigned int quadrature_point) const; /** - * Pointer to the array holding - * the values returned by - * inverse_jacobian(). + * Pointer to the array holding the values returned by inverse_jacobian(). */ const std::vector > &get_inverse_jacobians () const; /** - * For a face, return the outward - * normal vector to the cell at - * the ith quadrature - * point. + * For a face, return the outward normal vector to the cell at the + * ith quadrature point. * - * For a cell of codimension one, - * return the normal vector, as - * it is specified by the - * numbering of the vertices. + * For a cell of codimension one, return the normal vector, as it is + * specified by the numbering of the vertices. * - * The length of the vector - * is normalized to one. + * The length of the vector is normalized to one. */ const Point &normal_vector (const unsigned int i) const; /** - * Return the normal vectors at - * the quadrature points. For a - * face, these are the outward - * normal vectors to the - * cell. For a cell of - * codimension one, the - * orientation is given by the - * numbering of vertices. + * Return the normal vectors at the quadrature points. For a face, these are + * the outward normal vectors to the cell. For a cell of codimension one, + * the orientation is given by the numbering of vertices. */ const std::vector > &get_normal_vectors () const; /** - * Transform a set of vectors, - * one for each quadrature - * point. The mapping - * can be any of the ones defined - * in MappingType. + * Transform a set of vectors, one for each quadrature point. The + * mapping can be any of the ones defined in MappingType. */ void transform (std::vector > &transformed, const std::vector > &original, MappingType mapping) const; /** - * @deprecated Use - * normal_vector() instead. + * @deprecated Use normal_vector() instead. * - * Return the outward normal vector to - * the cell at the ith quadrature - * point. The length of the vector - * is normalized to one. + * Return the outward normal vector to the cell at the ith + * quadrature point. The length of the vector is normalized to one. */ const Point &cell_normal_vector (const unsigned int i) const DEAL_II_DEPRECATED; /** - * @deprecated Use - * get_normal_vectors() instead. + * @deprecated Use get_normal_vectors() instead. * - * Returns the vectors normal to - * the cell in each of the - * quadrature points. + * Returns the vectors normal to the cell in each of the quadrature points. */ const std::vector > &get_cell_normal_vectors () const DEAL_II_DEPRECATED; @@ -3082,56 +2133,41 @@ public: //@{ /** - * Create a view of the current FEValues - * object that represents a particular - * scalar component of the possibly - * vector-valued finite element. The - * concept of views is explained in the - * documentation of the namespace - * FEValuesViews and in particular - * in the @ref vector_valued module. + * Create a view of the current FEValues object that represents a particular + * scalar component of the possibly vector-valued finite element. The + * concept of views is explained in the documentation of the namespace + * FEValuesViews and in particular in the @ref vector_valued module. */ const FEValuesViews::Scalar & operator[] (const FEValuesExtractors::Scalar &scalar) const; /** - * Create a view of the current FEValues - * object that represents a set of - * dim scalar components - * (i.e. a vector) of the vector-valued - * finite element. The concept of views - * is explained in the documentation of - * the namespace FEValuesViews and in particular - * in the @ref vector_valued module. + * Create a view of the current FEValues object that represents a set of + * dim scalar components (i.e. a vector) of the vector-valued + * finite element. The concept of views is explained in the documentation of + * the namespace FEValuesViews and in particular in the @ref vector_valued + * module. */ const FEValuesViews::Vector & operator[] (const FEValuesExtractors::Vector &vector) const; /** - * Create a view of the current FEValues - * object that represents a set of - * (dim*dim + dim)/2 scalar components - * (i.e. a symmetric 2nd order tensor) - * of the vector-valued - * finite element. The concept of views - * is explained in the documentation of - * the namespace FEValuesViews and in particular - * in the @ref vector_valued module. + * Create a view of the current FEValues object that represents a set of + * (dim*dim + dim)/2 scalar components (i.e. a symmetric 2nd + * order tensor) of the vector-valued finite element. The concept of views + * is explained in the documentation of the namespace FEValuesViews and in + * particular in the @ref vector_valued module. */ const FEValuesViews::SymmetricTensor<2,dim,spacedim> & operator[] (const FEValuesExtractors::SymmetricTensor<2> &tensor) const; /** - * Create a view of the current FEValues - * object that represents a set of - * (dim*dim) scalar components - * (i.e. a 2nd order tensor) - * of the vector-valued - * finite element. The concept of views - * is explained in the documentation of - * the namespace FEValuesViews and in particular - * in the @ref vector_valued module. + * Create a view of the current FEValues object that represents a set of + * (dim*dim) scalar components (i.e. a 2nd order tensor) of the + * vector-valued finite element. The concept of views is explained in the + * documentation of the namespace FEValuesViews and in particular in the + * @ref vector_valued module. */ const FEValuesViews::Tensor<2,dim,spacedim> & operator[] (const FEValuesExtractors::Tensor<2> &tensor) const; @@ -3142,57 +2178,43 @@ public: //@{ /** - * Constant reference to the - * selected mapping object. + * Constant reference to the selected mapping object. */ const Mapping &get_mapping () const; /** - * Constant reference to the - * selected finite element - * object. + * Constant reference to the selected finite element object. */ const FiniteElement &get_fe () const; /** - * Return the update flags set - * for this object. + * Return the update flags set for this object. */ UpdateFlags get_update_flags () const; /** - * Return a triangulation - * iterator to the current cell. + * Return a triangulation iterator to the current cell. */ const typename Triangulation::cell_iterator get_cell () const; /** - * Return the relation of the current - * cell to the previous cell. This - * allows re-use of some cell data - * (like local matrices for equations - * with constant coefficients) if the - * result is - * CellSimilarity::translation. + * Return the relation of the current cell to the previous cell. This allows + * re-use of some cell data (like local matrices for equations with constant + * coefficients) if the result is CellSimilarity::translation. */ CellSimilarity::Similarity get_cell_similarity () const; /** - * Determine an estimate for the - * memory consumption (in bytes) - * of this object. + * Determine an estimate for the memory consumption (in bytes) of this + * object. */ std::size_t memory_consumption () const; //@} /** - * This exception is thrown if - * FEValuesBase is asked to - * return the value of a field - * which was not required by the - * UpdateFlags for this - * FEValuesBase. + * This exception is thrown if FEValuesBase is asked to return the value of + * a field which was not required by the UpdateFlags for this FEValuesBase. * * @ingroup Exceptions */ @@ -3237,110 +2259,73 @@ public: protected: /** - * Objects of the FEValues - * class need to store a pointer - * (i.e. an iterator) to the - * present cell in order to be - * able to extract the values of - * the degrees of freedom on this - * cell in the - * get_function_values() and - * assorted functions. On the - * other hand, this class should - * also work for different - * iterators, as long as they - * have the same interface to - * extract the DoF values (i.e., - * for example, they need to have - * a @p get_interpolated_dof_values - * function). + * Objects of the FEValues class need to store a pointer (i.e. an iterator) + * to the present cell in order to be able to extract the values of the + * degrees of freedom on this cell in the get_function_values() and assorted + * functions. On the other hand, this class should also work for different + * iterators, as long as they have the same interface to extract the DoF + * values (i.e., for example, they need to have a @p + * get_interpolated_dof_values function). * - * This calls for a common base - * class of iterator classes, and - * making the functions we need - * here @p virtual. On the other - * hand, this is the only place - * in the library where we need - * this, and introducing a base - * class of iterators and making - * a function virtual penalizes - * all users of the - * iterators, which are basically - * intended as very fast accessor - * functions. So we do not want - * to do this. Rather, what we do - * here is making the functions - * we need virtual only for use - * with this class. The idea - * is the following: have a - * common base class which - * declares some pure virtual - * functions, and for each - * possible iterator type, we - * have a derived class which - * stores the iterator to the - * cell and implements these - * functions. Since the iterator - * classes have the same - * interface, we can make the - * derived classes a template, - * templatized on the iterator - * type. + * This calls for a common base class of iterator classes, and making the + * functions we need here @p virtual. On the other hand, this is the only + * place in the library where we need this, and introducing a base class of + * iterators and making a function virtual penalizes all users of + * the iterators, which are basically intended as very fast accessor + * functions. So we do not want to do this. Rather, what we do here is + * making the functions we need virtual only for use with this + * class. The idea is the following: have a common base class which + * declares some pure virtual functions, and for each possible iterator + * type, we have a derived class which stores the iterator to the cell and + * implements these functions. Since the iterator classes have the same + * interface, we can make the derived classes a template, templatized on the + * iterator type. * - * This way, the use of virtual - * functions is restricted to - * only this class, and other - * users of iterators do not have - * to bear the negative effects. + * This way, the use of virtual functions is restricted to only this class, + * and other users of iterators do not have to bear the negative effects. * * @author Wolfgang Bangerth, 2003 */ class CellIteratorBase; /** - * Forward declaration of classes derived - * from CellIteratorBase. Their - * definition and implementation is given - * in the .cc file. + * Forward declaration of classes derived from CellIteratorBase. Their + * definition and implementation is given in the .cc file. */ template class CellIterator; class TriaCellIterator; /** - * Store the cell selected last time the - * reinit() function was called. This is - * necessary for the - * get_function_* functions as - * well as the functions of same name in - * the extractor classes. + * Store the cell selected last time the reinit() function was called. This + * is necessary for the get_function_* functions as well as the + * functions of same name in the extractor classes. */ std::auto_ptr present_cell; /** * A signal connection we use to ensure we get informed whenever the - * triangulation changes. We need to know about that because it - * invalidates all cell iterators and, as part of that, the - * 'present_cell' iterator we keep around between subsequent - * calls to reinit() in order to compute the cell similarity. + * triangulation changes. We need to know about that because it invalidates + * all cell iterators and, as part of that, the 'present_cell' iterator we + * keep around between subsequent calls to reinit() in order to compute the + * cell similarity. */ boost::signals2::connection tria_listener; /** - * A function that is connected to the triangulation in - * order to reset the stored 'present_cell' iterator to an invalid - * one whenever the triangulation is changed and the iterator consequently - * becomes invalid. + * A function that is connected to the triangulation in order to reset the + * stored 'present_cell' iterator to an invalid one whenever the + * triangulation is changed and the iterator consequently becomes invalid. */ void invalidate_present_cell (); /** * This function is called by the various reinit() functions in derived - * classes. Given the cell indicated by the argument, test whether - * we have to throw away the previously stored present_cell argument - * because it would require us to compare cells from different - * triangulations. In checking all this, also make sure that we have - * tria_listener connected to the triangulation to which we will set - * present_cell right after calling this function. + * classes. Given the cell indicated by the argument, test whether we have + * to throw away the previously stored present_cell argument because it + * would require us to compare cells from different triangulations. In + * checking all this, also make sure that we have tria_listener connected to + * the triangulation to which we will set present_cell right after calling + * this function. */ void maybe_invalidate_previous_present_cell (const typename Triangulation::cell_iterator &cell); @@ -3367,72 +2352,50 @@ protected: SmartPointer::InternalDataBase,FEValuesBase > fe_data; /** - * Initialize some update - * flags. Called from the - * @p initialize functions of - * derived classes, which are in - * turn called from their - * constructors. + * Initialize some update flags. Called from the @p initialize functions of + * derived classes, which are in turn called from their constructors. * - * Basically, this function finds - * out using the finite element - * and mapping object already - * stored which flags need to be - * set to compute everything the - * user wants, as expressed - * through the flags passed as - * argument. + * Basically, this function finds out using the finite element and mapping + * object already stored which flags need to be set to compute everything + * the user wants, as expressed through the flags passed as argument. */ UpdateFlags compute_update_flags (const UpdateFlags update_flags) const; /** - * An enum variable that can store - * different states of the current cell - * in comparison to the previously - * visited cell. If wanted, additional - * states can be checked here and used - * in one of the methods used during - * reinit. + * An enum variable that can store different states of the current cell in + * comparison to the previously visited cell. If wanted, additional states + * can be checked here and used in one of the methods used during reinit. */ CellSimilarity::Similarity cell_similarity; /** - * A function that checks whether the - * new cell is similar to the one - * previously used. Then, a significant - * amount of the data can be reused, - * e.g. the derivatives of the basis - * functions in real space, shape_grad. + * A function that checks whether the new cell is similar to the one + * previously used. Then, a significant amount of the data can be reused, + * e.g. the derivatives of the basis functions in real space, shape_grad. */ void check_cell_similarity (const typename Triangulation::cell_iterator &cell); private: /** - * Copy constructor. Since - * objects of this class are not - * copyable, we make it private, - * and also do not implement it. + * Copy constructor. Since objects of this class are not copyable, we make + * it private, and also do not implement it. */ FEValuesBase (const FEValuesBase &); /** - * Copy operator. Since - * objects of this class are not - * copyable, we make it private, - * and also do not implement it. + * Copy operator. Since objects of this class are not copyable, we make it + * private, and also do not implement it. */ FEValuesBase &operator= (const FEValuesBase &); /** - * A cache for all possible FEValuesViews - * objects. + * A cache for all possible FEValuesViews objects. */ dealii::internal::FEValuesViews::Cache fe_values_views_cache; /** - * Make the view classes friends of this - * class, since they access internal + * Make the view classes friends of this class, since they access internal * data. */ template friend class FEValuesViews::Scalar; @@ -3446,9 +2409,9 @@ private: /** * Finite element evaluated in quadrature points of a cell. * - * This function implements the initialization routines for - * FEValuesBase, if values in quadrature points of a cell are - * needed. For further documentation see this class. + * This function implements the initialization routines for FEValuesBase, if + * values in quadrature points of a cell are needed. For further documentation + * see this class. * * @ingroup feaccess * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001 @@ -3458,19 +2421,14 @@ class FEValues : public FEValuesBase { public: /** - * Dimension of the object over - * which we integrate. For the - * present class, this is equal - * to dim. + * Dimension of the object over which we integrate. For the present class, + * this is equal to dim. */ static const unsigned int integral_dimension = dim; /** - * Constructor. Gets cell - * independent data from mapping - * and finite element objects, - * matching the quadrature rule - * and update flags. + * Constructor. Gets cell independent data from mapping and finite element + * objects, matching the quadrature rule and update flags. */ FEValues (const Mapping &mapping, const FiniteElement &fe, @@ -3478,129 +2436,87 @@ public: const UpdateFlags update_flags); /** - * Constructor. Uses MappingQ1 - * implicitly. + * Constructor. Uses MappingQ1 implicitly. */ FEValues (const FiniteElement &fe, const Quadrature &quadrature, const UpdateFlags update_flags); /** - * Reinitialize the gradients, - * Jacobi determinants, etc for - * the given cell of type - * "iterator into a DoFHandler - * object", and the finite - * element associated with this - * object. It is assumed that the - * finite element used by the - * given cell is also the one - * used by this FEValues - * object. + * Reinitialize the gradients, Jacobi determinants, etc for the given cell + * of type "iterator into a DoFHandler object", and the finite element + * associated with this object. It is assumed that the finite element used + * by the given cell is also the one used by this FEValues object. */ template void reinit (const TriaIterator > cell); /** - * Reinitialize the gradients, - * Jacobi determinants, etc for - * the given cell of type - * "iterator into a Triangulation - * object", and the given finite - * element. Since iterators into - * triangulation alone only - * convey information about the - * geometry of a cell, but not - * about degrees of freedom - * possibly associated with this - * cell, you will not be able to - * call some functions of this - * class if they need information - * about degrees of - * freedom. These functions are, - * above all, the - * get_function_value/gradients/hessians/laplacians - * functions. If you want to call - * these functions, you have to - * call the @p reinit variants - * that take iterators into - * DoFHandler or other DoF - * handler type objects. + * Reinitialize the gradients, Jacobi determinants, etc for the given cell + * of type "iterator into a Triangulation object", and the given finite + * element. Since iterators into triangulation alone only convey information + * about the geometry of a cell, but not about degrees of freedom possibly + * associated with this cell, you will not be able to call some functions of + * this class if they need information about degrees of freedom. These + * functions are, above all, the + * get_function_value/gradients/hessians/laplacians functions. If + * you want to call these functions, you have to call the @p reinit variants + * that take iterators into DoFHandler or other DoF handler type objects. */ void reinit (const typename Triangulation::cell_iterator &cell); /** - * Return a reference to the copy - * of the quadrature formula - * stored by this object. + * Return a reference to the copy of the quadrature formula stored by this + * object. */ const Quadrature &get_quadrature () const; /** - * Determine an estimate for the - * memory consumption (in bytes) - * of this object. + * Determine an estimate for the memory consumption (in bytes) of this + * object. */ std::size_t memory_consumption () const; /** - * Return a reference to this - * very object. + * Return a reference to this very object. * - * Though it seems that it is not very - * useful, this function is there to - * provide capability to the hpFEValues - * class, in which case it provides the - * FEValues object for the present cell - * (remember that for hp finite elements, - * the actual FE object used may change - * from cell to cell, so we also need - * different FEValues objects for - * different cells; once you reinitialize - * the hpFEValues object for a specific - * cell, it retrieves the FEValues object - * for the FE on that cell and returns it - * through a function of the same name as - * this one; this function here therefore - * only provides the same interface so - * that one can templatize on - * FEValues/hpFEValues). + * Though it seems that it is not very useful, this function is there to + * provide capability to the hpFEValues class, in which case it provides the + * FEValues object for the present cell (remember that for hp finite + * elements, the actual FE object used may change from cell to cell, so we + * also need different FEValues objects for different cells; once you + * reinitialize the hpFEValues object for a specific cell, it retrieves the + * FEValues object for the FE on that cell and returns it through a function + * of the same name as this one; this function here therefore only provides + * the same interface so that one can templatize on FEValues/hpFEValues). */ const FEValues &get_present_fe_values () const; private: /** - * Store a copy of the quadrature - * formula here. + * Store a copy of the quadrature formula here. */ const Quadrature quadrature; /** - * Do work common to the two - * constructors. + * Do work common to the two constructors. */ void initialize (const UpdateFlags update_flags); /** - * The reinit() functions do - * only that part of the work - * that requires knowledge of the - * type of iterator. After - * setting present_cell(), - * they pass on to this function, - * which does the real work, and - * which is independent of the - * actual type of the cell - * iterator. + * The reinit() functions do only that part of the work that requires + * knowledge of the type of iterator. After setting present_cell(), they + * pass on to this function, which does the real work, and which is + * independent of the actual type of the cell iterator. */ void do_reinit (); }; /** - * Extend the interface of FEValuesBase to values that only make sense - * when evaluating something on the surface of a cell. All the data - * that is available in the interior of cells is also available here. + * Extend the interface of FEValuesBase to values that only make sense when + * evaluating something on the surface of a cell. All the data that is + * available in the interior of cells is also available here. * * See FEValuesBase * @@ -3612,30 +2528,21 @@ class FEFaceValuesBase : public FEValuesBase { public: /** - * Dimension of the object over - * which we integrate. For the - * present class, this is equal - * to dim-1. + * Dimension of the object over which we integrate. For the present class, + * this is equal to dim-1. */ static const unsigned int integral_dimension = dim-1; /** - * Constructor. Call the constructor of - * the base class and set up the arrays - * of this class with the right sizes. - * Actually filling these arrays is a - * duty of the derived class's - * constructors. + * Constructor. Call the constructor of the base class and set up the arrays + * of this class with the right sizes. Actually filling these arrays is a + * duty of the derived class's constructors. * - * @p n_faces_or_subfaces is the number - * of faces or subfaces that this object - * is to store. The actual number depends - * on the derived class, for - * FEFaceValues it is 2*dim, while for - * the FESubfaceValues class it is - * 2*dim*(1<<(dim-1)), i.e. the number - * of faces times the number of subfaces - * per face. + * @p n_faces_or_subfaces is the number of faces or subfaces that this + * object is to store. The actual number depends on the derived class, for + * FEFaceValues it is 2*dim, while for the FESubfaceValues class it + * is 2*dim*(1<<(dim-1)), i.e. the number of faces times the number + * of subfaces per face. */ FEFaceValuesBase (const unsigned int n_q_points, const unsigned int dofs_per_cell, @@ -3645,54 +2552,45 @@ public: const Quadrature& quadrature); /** - * Boundary form of the - * transformation of the cell at - * the ith quadrature point. - * See @ref GlossBoundaryForm . + * Boundary form of the transformation of the cell at the ith + * quadrature point. See @ref GlossBoundaryForm . */ const Tensor<1,spacedim> &boundary_form (const unsigned int i) const; /** - * Return the list of outward - * normal vectors times the - * Jacobian of the surface - * mapping. + * Return the list of outward normal vectors times the Jacobian of the + * surface mapping. */ const std::vector > &get_boundary_forms () const; /** - * Return the index of the face - * selected the last time the - * reinit() function was called. + * Return the index of the face selected the last time the reinit() function + * was called. */ unsigned int get_face_index() const; /** - * Return a reference to the copy - * of the quadrature formula - * stored by this object. + * Return a reference to the copy of the quadrature formula stored by this + * object. */ const Quadrature & get_quadrature () const; /** - * Determine an estimate for the - * memory consumption (in bytes) - * of this object. + * Determine an estimate for the memory consumption (in bytes) of this + * object. */ std::size_t memory_consumption () const; protected: /** - * Index of the face selected the - * last time the reinit() - * function was called. + * Index of the face selected the last time the reinit() function was + * called. */ unsigned int present_face_index; /** - * Store a copy of the quadrature - * formula here. + * Store a copy of the quadrature formula here. */ const Quadrature quadrature; }; @@ -3702,13 +2600,13 @@ protected: /** * Finite element evaluated in quadrature points on a face. * - * This class adds the functionality of FEFaceValuesBase to - * FEValues; see there for more documentation. + * This class adds the functionality of FEFaceValuesBase to FEValues; see + * there for more documentation. * - * Since finite element functions and their derivatives may be - * discontinuous at cell boundaries, there is no restriction of this - * function to a mesh face. But, there are limits of these values - * approaching the face from either of the neighboring cells. + * Since finite element functions and their derivatives may be discontinuous + * at cell boundaries, there is no restriction of this function to a mesh + * face. But, there are limits of these values approaching the face from + * either of the neighboring cells. * * @ingroup feaccess * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001 @@ -3718,8 +2616,7 @@ class FEFaceValues : public FEFaceValuesBase { public: /** - * Dimension in which this object - * operates. + * Dimension in which this object operates. */ static const unsigned int dimension = dim; @@ -3727,19 +2624,14 @@ public: static const unsigned int space_dimension = spacedim; /** - * Dimension of the object over - * which we integrate. For the - * present class, this is equal - * to dim-1. + * Dimension of the object over which we integrate. For the present class, + * this is equal to dim-1. */ static const unsigned int integral_dimension = dim-1; /** - * Constructor. Gets cell - * independent data from mapping - * and finite element objects, - * matching the quadrature rule - * and update flags. + * Constructor. Gets cell independent data from mapping and finite element + * objects, matching the quadrature rule and update flags. */ FEFaceValues (const Mapping &mapping, const FiniteElement &fe, @@ -3747,95 +2639,61 @@ public: const UpdateFlags update_flags); /** - * Constructor. Uses MappingQ1 - * implicitly. + * Constructor. Uses MappingQ1 implicitly. */ FEFaceValues (const FiniteElement &fe, const Quadrature &quadrature, const UpdateFlags update_flags); /** - * Reinitialize the gradients, Jacobi - * determinants, etc for the face with - * number @p face_no of @p cell - * and the given finite element. + * Reinitialize the gradients, Jacobi determinants, etc for the face with + * number @p face_no of @p cell and the given finite element. */ template void reinit (const TriaIterator > cell, const unsigned int face_no); /** - * Reinitialize the gradients, - * Jacobi determinants, etc for - * the given face on given cell - * of type "iterator into a - * Triangulation object", and the - * given finite element. Since - * iterators into triangulation - * alone only convey information - * about the geometry of a cell, - * but not about degrees of - * freedom possibly associated - * with this cell, you will not - * be able to call some functions - * of this class if they need - * information about degrees of - * freedom. These functions are, - * above all, the - * get_function_value/gradients/hessians - * functions. If you want to call - * these functions, you have to - * call the @p reinit variants - * that take iterators into - * DoFHandler or other DoF - * handler type objects. + * Reinitialize the gradients, Jacobi determinants, etc for the given face + * on given cell of type "iterator into a Triangulation object", and the + * given finite element. Since iterators into triangulation alone only + * convey information about the geometry of a cell, but not about degrees of + * freedom possibly associated with this cell, you will not be able to call + * some functions of this class if they need information about degrees of + * freedom. These functions are, above all, the + * get_function_value/gradients/hessians functions. If you want to + * call these functions, you have to call the @p reinit variants that take + * iterators into DoFHandler or other DoF handler type objects. */ void reinit (const typename Triangulation::cell_iterator &cell, const unsigned int face_no); /** - * Return a reference to this - * very object. + * Return a reference to this very object. * - * Though it seems that it is not very - * useful, this function is there to - * provide capability to the hpFEValues - * class, in which case it provides the - * FEValues object for the present cell - * (remember that for hp finite elements, - * the actual FE object used may change - * from cell to cell, so we also need - * different FEValues objects for - * different cells; once you reinitialize - * the hpFEValues object for a specific - * cell, it retrieves the FEValues object - * for the FE on that cell and returns it - * through a function of the same name as - * this one; this function here therefore - * only provides the same interface so - * that one can templatize on - * FEValues/hpFEValues). + * Though it seems that it is not very useful, this function is there to + * provide capability to the hpFEValues class, in which case it provides the + * FEValues object for the present cell (remember that for hp finite + * elements, the actual FE object used may change from cell to cell, so we + * also need different FEValues objects for different cells; once you + * reinitialize the hpFEValues object for a specific cell, it retrieves the + * FEValues object for the FE on that cell and returns it through a function + * of the same name as this one; this function here therefore only provides + * the same interface so that one can templatize on FEValues/hpFEValues). */ const FEFaceValues &get_present_fe_values () const; private: /** - * Do work common to the two - * constructors. + * Do work common to the two constructors. */ void initialize (const UpdateFlags update_flags); /** - * The reinit() functions do - * only that part of the work - * that requires knowledge of the - * type of iterator. After - * setting present_cell(), - * they pass on to this function, - * which does the real work, and - * which is independent of the - * actual type of the cell - * iterator. + * The reinit() functions do only that part of the work that requires + * knowledge of the type of iterator. After setting present_cell(), they + * pass on to this function, which does the real work, and which is + * independent of the actual type of the cell iterator. */ void do_reinit (const unsigned int face_no); }; @@ -3844,17 +2702,16 @@ private: /** * Finite element evaluated in quadrature points on a face. * - * This class adds the functionality of FEFaceValuesBase to - * FEValues; see there for more documentation. + * This class adds the functionality of FEFaceValuesBase to FEValues; see + * there for more documentation. * - * This class is used for faces lying on a refinement edge. In this - * case, the neighboring cell is refined. To be able to compute - * differences between interior and exterior function values, the - * refinement of the neighboring cell must be simulated on this - * cell. This is achieved by applying a quadrature rule that simulates - * the refinement. The resulting data fields are split up to reflect - * the refinement structure of the neighbor: a subface number - * corresponds to the number of the child of the neighboring face. + * This class is used for faces lying on a refinement edge. In this case, the + * neighboring cell is refined. To be able to compute differences between + * interior and exterior function values, the refinement of the neighboring + * cell must be simulated on this cell. This is achieved by applying a + * quadrature rule that simulates the refinement. The resulting data fields + * are split up to reflect the refinement structure of the neighbor: a subface + * number corresponds to the number of the child of the neighboring face. * * @ingroup feaccess * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001 @@ -3864,31 +2721,24 @@ class FESubfaceValues : public FEFaceValuesBase { public: /** - * Dimension in which this object - * operates. + * Dimension in which this object operates. */ static const unsigned int dimension = dim; /** - * Dimension of the space in - * which this object operates. + * Dimension of the space in which this object operates. */ static const unsigned int space_dimension = spacedim; /** - * Dimension of the object over - * which we integrate. For the - * present class, this is equal - * to dim-1. + * Dimension of the object over which we integrate. For the present class, + * this is equal to dim-1. */ static const unsigned int integral_dimension = dim-1; /** - * Constructor. Gets cell - * independent data from mapping - * and finite element objects, - * matching the quadrature rule - * and update flags. + * Constructor. Gets cell independent data from mapping and finite element + * objects, matching the quadrature rule and update flags. */ FESubfaceValues (const Mapping &mapping, const FiniteElement &fe, @@ -3896,25 +2746,17 @@ public: const UpdateFlags update_flags); /** - * Constructor. Uses MappingQ1 - * implicitly. + * Constructor. Uses MappingQ1 implicitly. */ FESubfaceValues (const FiniteElement &fe, const Quadrature &face_quadrature, const UpdateFlags update_flags); /** - * Reinitialize the gradients, - * Jacobi determinants, etc for - * the given cell of type - * "iterator into a DoFHandler - * object", and the finite - * element associated with this - * object. It is assumed that the - * finite element used by the - * given cell is also the one - * used by this - * FESubfaceValues object. + * Reinitialize the gradients, Jacobi determinants, etc for the given cell + * of type "iterator into a DoFHandler object", and the finite element + * associated with this object. It is assumed that the finite element used + * by the given cell is also the one used by this FESubfaceValues object. */ template void reinit (const TriaIterator > cell, @@ -3922,57 +2764,33 @@ public: const unsigned int subface_no); /** - * Reinitialize the gradients, - * Jacobi determinants, etc for - * the given subface on given - * cell of type "iterator into a - * Triangulation object", and the - * given finite element. Since - * iterators into triangulation - * alone only convey information - * about the geometry of a cell, - * but not about degrees of - * freedom possibly associated - * with this cell, you will not - * be able to call some functions - * of this class if they need - * information about degrees of - * freedom. These functions are, - * above all, the - * get_function_value/gradients/hessians - * functions. If you want to call - * these functions, you have to - * call the @p reinit variants - * that take iterators into - * DoFHandler or other DoF - * handler type objects. + * Reinitialize the gradients, Jacobi determinants, etc for the given + * subface on given cell of type "iterator into a Triangulation object", and + * the given finite element. Since iterators into triangulation alone only + * convey information about the geometry of a cell, but not about degrees of + * freedom possibly associated with this cell, you will not be able to call + * some functions of this class if they need information about degrees of + * freedom. These functions are, above all, the + * get_function_value/gradients/hessians functions. If you want to + * call these functions, you have to call the @p reinit variants that take + * iterators into DoFHandler or other DoF handler type objects. */ void reinit (const typename Triangulation::cell_iterator &cell, const unsigned int face_no, const unsigned int subface_no); /** - * Return a reference to this - * very object. + * Return a reference to this very object. * - * Though it seems that it is not very - * useful, this function is there to - * provide capability to the hpFEValues - * class, in which case it provides the - * FEValues object for the present cell - * (remember that for hp finite elements, - * the actual FE object used may change - * from cell to cell, so we also need - * different FEValues objects for - * different cells; once you reinitialize - * the hpFEValues object for a specific - * cell, it retrieves the FEValues object - * for the FE on that cell and returns it - * through a function of the same name as - * this one; this function here therefore - * only provides the same interface so - * that one can templatize on - * FEValues/hpFEValues). + * Though it seems that it is not very useful, this function is there to + * provide capability to the hpFEValues class, in which case it provides the + * FEValues object for the present cell (remember that for hp finite + * elements, the actual FE object used may change from cell to cell, so we + * also need different FEValues objects for different cells; once you + * reinitialize the hpFEValues object for a specific cell, it retrieves the + * FEValues object for the FE on that cell and returns it through a function + * of the same name as this one; this function here therefore only provides + * the same interface so that one can templatize on FEValues/hpFEValues). */ const FESubfaceValues &get_present_fe_values () const; @@ -3993,22 +2811,15 @@ public: private: /** - * Do work common to the two - * constructors. + * Do work common to the two constructors. */ void initialize (const UpdateFlags update_flags); /** - * The reinit() functions do - * only that part of the work - * that requires knowledge of the - * type of iterator. After - * setting present_cell(), - * they pass on to this function, - * which does the real work, and - * which is independent of the - * actual type of the cell - * iterator. + * The reinit() functions do only that part of the work that requires + * knowledge of the type of iterator. After setting present_cell(), they + * pass on to this function, which does the real work, and which is + * independent of the actual type of the cell iterator. */ void do_reinit (const unsigned int face_no, const unsigned int subface_no); @@ -4034,12 +2845,9 @@ namespace FEValuesViews Assert (fe_values.update_flags & update_values, typename FVB::ExcAccessToUninitializedField()); - // an adaptation of the - // FEValuesBase::shape_value_component - // function except that here we know the - // component as fixed and we have - // pre-computed and cached a bunch of - // information. see the comments there + // an adaptation of the FEValuesBase::shape_value_component function + // except that here we know the component as fixed and we have + // pre-computed and cached a bunch of information. see the comments there if (shape_function_data[shape_function].is_nonzero_shape_function_component) return fe_values.shape_values(shape_function_data[shape_function] .row_index, -- 2.39.5