New: Added a third test variant to the testsuite driver: For a test
consisting of a test.prm.in (and a test.output) file the test.prm.in file
will be configured/preprocessed to a test.prm file. This is done with the
-CMake macro CONFIGURE_FILE that replaces all strings @VARIABLE@ with the
+CMake macro CONFIGURE_FILE that replaces all strings \@VARIABLE\@ with the
contents of the corresponding CMake variable. This is useful in particular
-to conveniently substitute @SOURCE_DIR@ with the full source directory path
+to conveniently substitute \@SOURCE_DIR\@ with the full source directory path
of the test.
<br>
(Matthias Maier, 2018/03/21)
* Consequently, the return type of this function is a view to a set of
* @p non-const objects.
*
- * @param[in] table The LAPACKFullMatrix for which we want to have an array
+ * @param[in] matrix The LAPACKFullMatrix for which we want to have an array
* view object. The array view corresponds to the <em>entire</em> object but
* the order in which the entries are presented in the array is an
* implementation detail and should not be relied upon.
* type because they contain immutable elements. Consequently, the return type
* of this function is a view to a set of @p const objects.
*
- * @param[in] table The LAPACKFullMatrix for which we want to have an array
+ * @param[in] matrix The LAPACKFullMatrix for which we want to have an array
* view object. The array view corresponds to the <em>entire</em> object but
* the order in which the entries are presented in the array is an
* implementation detail and should not be relied upon.
* @p ghost_array to zero for the implementation-dependent cases when it
* was not already done in the import_from_ghosted_array_start() call.
*
- * @param locally_owned_array The array of data where the resulting data
+ * @param locally_owned_storage The array of data where the resulting data
* sent by remote processes to the calling process will be accumulated
* into.
*
template <typename Number>
void
import_from_ghosted_array_finish(const VectorOperation::values vector_operation,
- const ArrayView<const Number> &temporary_array,
+ const ArrayView<const Number> &temporary_storage,
const ArrayView<Number> &locally_owned_storage,
const ArrayView<Number> &ghost_array,
std::vector<MPI_Request> &requests) const;
* \begin{pmatrix}
* \hat x^\beta (1-\hat y)\\
* \hat x^\beta \hat y
- * end{pmatrix}
+ * \end{pmatrix}
* \f]
*
* with determinant of the Jacobian equal to $J= \beta \hat \x^{2\beta-1}$.
* Call the above constructor with QGauss<1>(n) quadrature formulas for
* both the radial and angular quadratures.
*
- * @param n
+ * @param n Order of QGauss quadrature
*/
QDuffy(const unsigned int n,
const double beta);
*
* The constructor requires that exactly one of
* <code>partition_auto</code>, <code>partition_metis</code>,
- * <code>partition_zorder</code>, <code>partition_zoltan> and
+ * <code>partition_zorder</code>, <code>partition_zoltan</code> and
* <code>partition_custom_signal</code> is set. If
* <code>partition_auto</code> is chosen, it will use
* <code>partition_zoltan</code> (if available), then
* <code>partition_metis</code> (if available) and finally
- * <code>partition_zorder>.
+ * <code>partition_zorder</code>.
*/
enum Settings
{
BoundingBox<spacedim> compute_bounding_box(const Triangulation<dim, spacedim> &triangulation);
/**
- * Return the point on the geometrical object @object closest to the given
+ * Return the point on the geometrical object @p object closest to the given
* point @p trial_point. For example, if @p object is a one-dimensional line
* or edge, then the returned point will be a point on the geodesic that
* connects the vertices as the manifold associated with the object sees it
* - Cells, is a vector of a vector cells of the all cells
* containing at least one of the @p points .
* - A vector qpoints of vector of points, containing in @p qpoints[i]
- * the reference positions of all points that fall within the cell @P cells[i] .
+ * the reference positions of all points that fall within the cell @p cells[i] .
* - A vector indices of vector of integers, containing the mapping between
* local numbering in qpoints, and global index in points
*
* - cells : a vector of cells of the all cells containing at
* least a point.
* - qpoints : a vector of vector of points; containing in @p qpoints[i]
- * the reference positions of all points that fall within the cell @P cells[i] .
+ * the reference positions of all points that fall within the cell @p cells[i] .
* - maps : a vector of vector of integers, containing the mapping between
* the numbering in qpoints (previous element of the tuple), and the vector
* of local points of the process owning the points.
*
* This class has five template arguments:
*
- * @ptaram dim Dimension in which this class is to be used
+ * @tparam dim Dimension in which this class is to be used
*
* @tparam fe_degree Degree of the tensor prodict finite element with fe_degree+1
* degrees of freedom per coordinate direction
const bool evaluate_hessians);
/**
- * Based on the the run time parameters stored in @shape_info this function
+ * Based on the the run time parameters stored in @p shape_info this function
* chooses an appropriate evaluation strategy for the integrate function, i.e.
* this calls internal::FEEvaluationImpl::integrate(),
* internal::FEEvaluationImplCollocation::integrate() or
value_type dot (const ROL::Vector<value_type> &rol_vector) const;
/**
- * Return the \f$ L^{2} \f$ norm of the wrapped vector.
+ * Return the $L^{2}$ norm of the wrapped vector.
*
* The returned type is of VectorAdaptor::value_type so as to maintain
* consistency with ROL::Vector<VectorAdaptor::value_type> and
/**
* Create and return a Teuchos smart reference counting pointer to the basis
- * vector corresponding to the @p i \f${}^{th}\f$ element of
+ * vector corresponding to the @p i ${}^{th}$ element of
* the wrapper vector.
*/
Teuchos::RCP<ROL::Vector<value_type>> basis (const int i) const;
* \f]
* must be solved for each stage $z_i , i = 1, \ldot, s$, where
* we have the data
- * \[
+ * \f[
* a_i := M y_{n−1} + h_n \sum_{j=1}^{i−1} [ A^E_{i,j} f_E(t^E_{n,j}, z_j)
* + A^I_{i,j} f_I (t^I_{n,j}, z_j)]
- * \]
+ * \f]
* for the ARK methods, or
- * \[
+ * \f[
* a_i := M y_{n−1} + h_n \sum_{j=1}^{i−1} A^I_{i,j} f_I (t^I_{n,j}, z_j)
- * \]
+ * \f]
* for the DIRK methods. Here $A^I_{i,j}$ and $A^E_{i,j}$ are the Butcher's
* tables for the chosen solver.
*
*
* For systems of either type, ARKode allows a choice of solution strategy.
* The default solver choice is a variant of Newton’s method,
- * \[
+ * \f[
* z_i^{m+1} = z_i^m +\delta^{m+1},
- * \]
+ * \f]
* where $m$ is the Newton index, and the Newton update $\delta^{m+1}$
* requires the solution of the linear Newton system
- * \[
+ * \f[
* N(z_i^m) \delta^{m+1} = -G(z_i^m),
- * \]
+ * \f]
* where
- * \[
+ * \f[
* N := M - \gamma J, \quad J := \frac{\partial f_I}{\partial y},
* \qquad \gamma:= h_n A^I_{i,i}.
- * \]
+ * \f]
*
* As an alternate to Newton’s method, ARKode may solve for each stage $z_i ,i
* = 1, \ldots , s$ using an Anderson-accelerated fixed point iteration
- * \[
+ * \f[
* z_i^{m+1} = g(z_i^{m}), m=0,1,\ldots.
- * \]
+ * \f]
*
* Unlike with Newton’s method, this option does not require the solution of
* a linear system at each iteration, instead opting for solution of a
projects / dealii.git / commitdiff