//@{
/**
- * Returns whether or not this class is tracking calculations performed
+ * Return whether or not this class is tracking calculations performed
* with its marked independent variables.
*/
bool
is_recording() const;
/**
- * Returns the tape number which is currently activated for recording or
+ * Return the tape number which is currently activated for recording or
* reading.
*/
typename Types<ADNumberType>::tape_index
active_tape_index() const;
/**
- * Returns whether or not a tape number has already been used
+ * Return whether or not a tape number has already been used
* or registered.
*/
bool
const typename Types<ADNumberType>::tape_index tape_index) const;
/**
- * Returns whether or not the numerical values of all independent
+ * Return whether or not the numerical values of all independent
* variables are recorded in the tape buffer.
*/
bool
reset(const bool clear_registered_tapes);
/**
- * Prints the status of all queriable data. Exactly what is printed and
+ * Print the status of all queriable data. Exactly what is printed and
* its format depends on the @p ad_type, as is determined by the
* @p ADNumberTypeCode template parameter.
*
//@{
/**
- * Computes the value of the scalar field.
+ * Compute the value of the scalar field.
*
* @param[in] active_tape_index The index of the tape on which the
* dependent function is recorded.
const std::vector<ScalarType> &independent_variables);
/**
- * Computes the gradient of the scalar field with respect to all
+ * Compute the gradient of the scalar field with respect to all
* independent variables.
*
* @param[in] active_tape_index The index of the tape on which the
Vector<ScalarType> & gradient);
/**
- * Computes the Hessian of the scalar field with respect to all
+ * Compute the Hessian of the scalar field with respect to all
* independent variables.
*
* @param[in] active_tape_index The index of the tape on which the
//@{
/**
- * Computes the values of the vector field.
+ * Compute the values of the vector field.
*
* @param[in] active_tape_index The index of the tape on which the
* dependent function is recorded.
Vector<ScalarType> & values);
/**
- * Computes the Jacobian of the vector field.
+ * Compute the Jacobian of the vector field.
*
* The Jacobian of a vector field is in essence the gradient of each
* dependent variable with respect to all independent variables.
//@{
/**
- * Computes the value of the scalar field.
+ * Compute the value of the scalar field.
*
* @param[in] dependent_variables The dependent variables whose values are
* to be extracted.
value(const std::vector<ADNumberType> &dependent_variables);
/**
- * Computes the gradient of the scalar field with respect to all
+ * Compute the gradient of the scalar field with respect to all
* independent variables.
*
* @param[in] independent_variables The independent variables whose
Vector<ScalarType> & gradient);
/**
- * Computes the Hessian of the scalar field with respect to all
+ * Compute the Hessian of the scalar field with respect to all
* independent variables.
*
* @param[in] independent_variables The independent variables whose
//@{
/**
- * Computes the values of the vector field.
+ * Compute the values of the vector field.
*
* @param[in] dependent_variables The dependent variables whose Hessians
* are to be extracted.
Vector<ScalarType> & values);
/**
- * Computes the Jacobian of the vector field.
+ * Compute the Jacobian of the vector field.
*
* The Jacobian of a vector field is in essence the gradient of each
* dependent variable with respect to all independent variables.
//@{
/**
- * Returns the number of independent variables that this object expects to
+ * Return the number of independent variables that this object expects to
* work with. This is the dimension of the domain space.
*/
std::size_t
n_independent_variables() const;
/**
- * Returns the number of dependent variables that this object expects to
+ * Return the number of dependent variables that this object expects to
* operate on. This is the dimension of the image space.
*/
std::size_t
n_dependent_variables() const;
/**
- * Prints the status of all queryable data. Exactly what is printed and
+ * Print the status of all queryable data. Exactly what is printed and
* its format depends on the @p ad_type, as is determined by the
* @p ADNumberTypeCode template parameter.
*
print(std::ostream &stream) const;
/**
- * Prints the values currently assigned to the independent variables.
+ * Print the values currently assigned to the independent variables.
*
* @param[in] stream The output stream to which the values are to be
* written.
print_values(std::ostream &stream) const;
/**
- * Prints the statistics regarding the usage of the tapes.
+ * Print the statistics regarding the usage of the tapes.
*
* @param[in] tape_index The index of the tape to get the statistics of.
* @param[out] stream The output stream to which the values are to be
const bool clear_registered_tapes = true);
/**
- * Returns whether or not this class is tracking calculations performed
+ * Return whether or not this class is tracking calculations performed
* with its marked independent variables.
*/
bool
is_recording() const;
/**
- * Returns the tape index which is currently activated for recording or
+ * Return the tape index which is currently activated for recording or
* reading.
*/
typename Types<ad_type>::tape_index
active_tape_index() const;
/**
- * Returns whether or not a tape number has already been used
+ * Return whether or not a tape number has already been used
* or registered.
*/
bool
const std::vector<dealii::types::global_dof_index> &local_dof_indices);
/**
- * Returns the complete set of degree of freedom values as represented by
+ * Return the complete set of degree of freedom values as represented by
* auto-differentiable numbers. These are the independent
* variables $\mathbf{X}$ about which the solution is linearized.
*
//@{
/*
- * Returns the complete set of degree of freedom values of
+ * Return the complete set of degree of freedom values of
* auto-differentiable number type. These store the same scalar values as
* the independent variables $\mathbf{X}$ about which the solution is
* linearized.
//@{
/**
- * Computes the value of the residual vector field
+ * Compute the value of the residual vector field
* $\mathbf{r}(\mathbf{X})$.
*
* @param[out] residual A Vector object with the value for each component
compute_residual(Vector<scalar_type> &residual) const = 0;
/**
- * Computes the gradient (first derivative) of the residual vector field
+ * Compute the gradient (first derivative) of the residual vector field
* with respect to all independent variables, i.e.
* @f[
* \frac{\partial\mathbf{r}(\mathbf{X})}{\partial\mathbf{X}}
compute_residual(Vector<scalar_type> &residual) const override;
/**
- * Computes the linearization of the residual vector around a chosen set
+ * Compute the linearization of the residual vector around a chosen set
* of degree of freedom values. Underlying this is the computation of the
* Hessian (second derivative) of the scalar function $\Psi$ with respect
* to all independent variables, i.e.
compute_residual(Vector<scalar_type> &residual) const override;
/**
- * Computes the linearization of the residual vector around a chosen set
+ * Compute the linearization of the residual vector around a chosen set
* of degree of freedom values. Underlying this is the computation of the
* gradient (first derivative) of the residual vector $\mathbf{r}$ with
* respect to all independent variables, i.e.
const MappingCollection<dim, spacedim> &mapping_collection);
/**
- * Adds a new mapping to the MappingCollection. Generally, you will
+ * Add a new mapping to the MappingCollection. Generally, you will
* want to use the same order for mappings as for the elements of
* the hp::FECollection object you use. However, the same
* considerations as discussed with the hp::QCollection::push_back()
explicit QCollection(const QTypes &... quadrature_objects);
/**
- * Adds a new quadrature rule to the QCollection. In most cases, you will
+ * Add a new quadrature rule to the QCollection. In most cases, you will
* want to add quadrature rules in the same order as the elements were
* added to the hp::FECollection for which this quadrature rule collection
* is meant. If done this way, the hp::FEValues objects with which you will
copy_indices_level_mine;
/**
- * Stores whether the copy operation from the global to the level vector is
- * actually a plain copy to the finest level. This means that the grid has
- * no adaptive refinement and the numbering on the finest multigrid level is
- * the same as in the global case.
+ * This variable stores whether the copy operation from the global to the
+ * level vector is actually a plain copy to the finest level. This means that
+ * the grid has no adaptive refinement and the numbering on the finest
+ * multigrid level is the same as in the global case.
*/
bool perform_plain_copy;
solution_copy_indices_level_mine;
/**
- * Stores whether the copy operation from the global to the level vector is
- * actually a plain copy to the finest level. This means that the grid has
- * no adaptive refinement and the numbering on the finest multigrid level is
- * the same as in the global case.
+ * This variable stores whether the copy operation from the global to the
+ * level vector is actually a plain copy to the finest level. This means that
+ * the grid has no adaptive refinement and the numbering on the finest
+ * multigrid level is the same as in the global case.
*/
bool perform_plain_copy;
/**
- * Stores whether the copy operation from the global to the level vector is
- * actually a plain copy to the finest level except for a renumbering within
- * the finest level of the degrees of freedom. This means that the grid has
- * no adaptive refinement.
+ * This variable stores whether the copy operation from the global to the
+ * level vector is actually a plain copy to the finest level except for a
+ * renumbering within the finest level of the degrees of freedom. This means
+ * that the grid has no adaptive refinement.
*/
bool perform_renumbered_plain_copy;
std::vector<std::shared_ptr<BlockSparseMatrix<double>>> prolongation_matrices;
/**
- * Holds the mapping for the <tt>copy_to/from_mg</tt>-functions. The data is
- * first the global index, then the level index.
+ * This variable holds the mapping for the <tt>copy_to/from_mg</tt>-functions.
+ * The data is first the global index, then the level index.
*/
std::vector<std::vector<std::pair<types::global_dof_index, unsigned int>>>
copy_to_and_from_indices;
std::vector<unsigned int> lexicographic_numbering;
/**
- * Holds the one-dimensional embedding (prolongation) matrix from mother
- * element to all the children.
+ * This variable holds the one-dimensional embedding (prolongation) matrix
+ * from mother element to all the children.
*/
std::vector<Number> prolongation_matrix_1d;
};
unsigned int n_child_cell_dofs;
/**
- * Holds the indices for cells on a given level, extracted from DoFHandler
- * for fast access. All DoF indices on a given level are stored as a plain
- * array (since this class assumes constant DoFs per cell). To index into
- * this array, use the cell number times dofs_per_cell.
+ * This variable holds the indices for cells on a given level, extracted from
+ * DoFHandler for fast access. All DoF indices on a given level are stored as
+ * a plain array (since this class assumes constant DoFs per cell). To index
+ * into this array, use the cell number times dofs_per_cell.
*
* This array first is arranged such that all locally owned level cells come
* first (found in the variable n_owned_level_cells) and then other cells
std::vector<unsigned int> n_owned_level_cells;
/**
- * Holds the one-dimensional embedding (prolongation) matrix from mother
- * element to all the children.
+ * This variable holds the one-dimensional embedding (prolongation) matrix
+ * from mother element to all the children.
*/
AlignedVector<VectorizedArray<Number>> prolongation_matrix_1d;
/**
- * Holds the temporary values for the tensor evaluation
+ * This variable holds the temporary values for the tensor evaluation
*/
mutable AlignedVector<VectorizedArray<Number>> evaluation_data;
namespace NonMatching
{
/**
- * Defines a quadrature formula for integration over an oriented surface,
- * $\hat{S}$, immersed in the unit cell. By immersed it is meant that the
- * surface may intersect the unit cell in an arbitrary way. The quadrature
- * formula is described by a set of quadrature points, $\hat{x}_q$, weights,
- * $w_q$, and normalized surface normals, $\hat{n}_q$.
+ * This class defines a quadrature formula for integration over an
+ * oriented surface, $\hat{S}$, immersed in the unit cell. By
+ * immersed it is meant that the surface may intersect the unit cell
+ * in an arbitrary way. The quadrature formula is described by a set
+ * of quadrature points, $\hat{x}_q$, weights, $w_q$, and normalized
+ * surface normals, $\hat{n}_q$.
*
* We typically want to compute surface integrals in real space.
* A surface $S$ intersecting a cell $K$ in real space, can be mapped onto a
unsigned int maximum_non_linear_iterations;
/**
- * Specifies that the implicit portion of the problem is linear.
+ * Specify whether the implicit portion of the problem is linear.
*/
bool implicit_function_is_linear;
/**
- * Specifies that the implicit portion of the problem is linear and time
+ * Specify whether the implicit portion of the problem is linear and time
* independent.
*/
bool implicit_function_is_time_independent;
projects / dealii.git / commitdiff