]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Link to the glossary entry for 'mass matrix'.
authorWolfgang Bangerth <bangerth@colostate.edu>
Fri, 24 Feb 2023 01:34:10 +0000 (18:34 -0700)
committerWolfgang Bangerth <bangerth@colostate.edu>
Fri, 24 Feb 2023 01:34:10 +0000 (18:34 -0700)
81 files changed:
doc/doxygen/headers/glossary.h
doc/doxygen/headers/vector_valued.h
examples/step-11/step-11.cc
examples/step-20/doc/intro.dox
examples/step-20/step-20.cc
examples/step-22/doc/intro.dox
examples/step-22/step-22.cc
examples/step-23/step-23.cc
examples/step-24/step-24.cc
examples/step-25/doc/intro.dox
examples/step-26/doc/intro.dox
examples/step-26/doc/results.dox
examples/step-28/doc/intro.dox
examples/step-28/step-28.cc
examples/step-31/doc/intro.dox
examples/step-32/doc/intro.dox
examples/step-36/doc/intro.dox
examples/step-36/step-36.cc
examples/step-37/step-37.cc
examples/step-41/doc/intro.dox
examples/step-41/step-41.cc
examples/step-42/step-42.cc
examples/step-43/doc/intro.dox
examples/step-43/step-43.cc
examples/step-48/doc/intro.dox
examples/step-52/doc/intro.dox
examples/step-52/step-52.cc
examples/step-55/doc/intro.dox
examples/step-55/step-55.cc
examples/step-56/doc/intro.dox
examples/step-56/step-56.cc
examples/step-57/doc/intro.dox
examples/step-57/step-57.cc
examples/step-59/step-59.cc
examples/step-61/doc/intro.dox
examples/step-61/step-61.cc
examples/step-62/step-62.cc
examples/step-67/doc/intro.dox
examples/step-69/doc/intro.dox
examples/step-69/step-69.cc
examples/step-70/step-70.cc
examples/step-78/step-78.cc
examples/step-82/doc/intro.dox
examples/step-82/step-82.cc
include/deal.II/algorithms/theta_timestepping.h
include/deal.II/base/polynomial.h
include/deal.II/base/quadrature_point_data.h
include/deal.II/dofs/dof_tools.h
include/deal.II/fe/fe_dgp.h
include/deal.II/fe/fe_dgp_monomial.h
include/deal.II/fe/fe_dgq.h
include/deal.II/fe/fe_q.h
include/deal.II/fe/fe_rt_bubbles.h
include/deal.II/fe/fe_simplex_p_bubbles.h
include/deal.II/fe/fe_tools.h
include/deal.II/integrators/l2.h
include/deal.II/integrators/local_integrators.h
include/deal.II/lac/arpack_solver.h
include/deal.II/lac/block_matrix_base.h
include/deal.II/lac/chunk_sparse_matrix.h
include/deal.II/lac/cuda_sparse_matrix.h
include/deal.II/lac/full_matrix.h
include/deal.II/lac/matrix_block.h
include/deal.II/lac/parpack_solver.h
include/deal.II/lac/petsc_matrix_base.h
include/deal.II/lac/petsc_sparse_matrix.h
include/deal.II/lac/schur_complement.h
include/deal.II/lac/slepc_solver.h
include/deal.II/lac/sparse_matrix.h
include/deal.II/lac/tensor_product_matrix.h
include/deal.II/lac/tridiagonal_matrix.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/matrix_free/evaluation_kernels.h
include/deal.II/matrix_free/operators.h
include/deal.II/non_matching/coupling.h
include/deal.II/numerics/matrix_creator.h
include/deal.II/numerics/tensor_product_matrix_creator.h
include/deal.II/numerics/vector_tools.h
include/deal.II/numerics/vector_tools_boundary.h
include/deal.II/numerics/vector_tools_project.h
include/deal.II/sundials/arkode.h

index 3d1c332a91b5fe32eaf3718ac6fc0792ee67a065..7e57dfc1b915e7fa24635c8dcb13f13389e4c712 100644 (file)
@@ -77,7 +77,7 @@
   \end{array}\right),
  * @f}
  * where $U,P$ are the values of velocity and pressure degrees of freedom,
- * respectively, $M$ is the mass matrix on the velocity space, $B$ corresponds to
+ * respectively, $M$ is the @ref GlossMassMatrix "mass matrix" on the velocity space, $B$ corresponds to
  * the negative divergence operator, and $B^T$ is its transpose and corresponds
  * to the negative gradient.
  *
index 4231f860511bb20951945e1db5d52785f517cdb4..fd1ad5a735d72eb83af63b64d88cb464f4b7476e 100644 (file)
   \begin{array}{cc} M & B \\ B^T & 0 \end{array}
   \right),
 @f}
- * where $M$ represents the mass matrix that results from discretizing the
+ * where $M$ represents the @ref GlossMassMatrix "mass matrix" that results from discretizing the
  * identity operator $\mathbf 1$ and $B$ the equivalent of the gradient
  * operator.
  *
index 1a3679592388332b5a4b677d07a25e9fa27a194d..8e7df42e14c186d84bfeba551f54f57a91379f3b 100644 (file)
@@ -266,7 +266,7 @@ namespace Step11
     // That's quite simple, right?
     //
     // Two remarks are in order, though: First, these functions are used in a
-    // lot of contexts. Maybe you want to create a Laplace or mass matrix for
+    // lot of contexts. Maybe you want to create a Laplace or @ref GlossMassMatrix "mass matrix" for
     // a vector values finite element; or you want to use the default Q1
     // mapping; or you want to assembled the matrix with a coefficient in the
     // Laplace operator. For this reason, there are quite a large number of
index 246eb87f694e5b5b4903986cbf248e013a7448ff..de94225f50b65c4042b90822cc4a81032852f2c9 100644 (file)
@@ -476,7 +476,7 @@ then we can subdivide the linear system $Ax=b$ into the following blocks:
   \end{array}\right),
 @f}
 where $U,P$ are the values of velocity and pressure degrees of freedom,
-respectively, $M$ is the mass matrix on the velocity space, $B^T$ corresponds to
+respectively, $M$ is the @ref GlossMassMatrix "mass matrix" on the velocity space, $B^T$ corresponds to
 the negative divergence operator, and $B$ is its transpose and corresponds
 to the gradient.
 
index d127d7acdaadd1dcc8e77e6d0a88836d0834cfb2..8104071667d8ddb156a27176a7ebd798ed1c90bb 100644 (file)
@@ -634,7 +634,7 @@ namespace Step20
     // After we have the pressure, we can compute the velocity. The equation
     // reads $MU=-BP+F$, and we solve it by first computing the right hand
     // side, and then multiplying it with the object that represents the
-    // inverse of the mass matrix:
+    // inverse of the @ref GlossMassMatrix "mass matrix":
     U = op_M_inv * (F - op_B * P);
   }
 
index a11a1697e256b8f6cf9c7c6639fd94e69f0be438..0fdabb98fc085885b18bead242308339e69e1c61 100644 (file)
@@ -448,7 +448,7 @@ elaborate preconditioning scheme for the Schur complement.
 
 <li>
 Second, every time we multiplied with $B^TM^{-1}B$ we had to solve with the
-mass matrix $M$. This wasn't particularly difficult, however, since the mass
+@ref GlossMassMatrix "mass matrix" $M$. This wasn't particularly difficult, however, since the mass
 matrix is always well conditioned and so simple to invert using CG and a
 little bit of preconditioning.
 </ol>
@@ -484,7 +484,7 @@ this Schur complement in a straightforward way with the CG method:
 using no preconditioner, the condition number of the Schur complement matrix
 depends on the size ratios of the largest to the smallest cells, and one still
 needs on the order of 50-100 CG iterations. However, there is a simple cure:
-precondition with the mass matrix on the pressure space and we get down to a
+precondition with the @ref GlossMassMatrix "mass matrix" on the pressure space and we get down to a
 number between 5-15 CG iterations, pretty much independently of the structure
 of the mesh (take a look at the <a href="#Results">results section</a> of this
 program to see that indeed the number of CG iterations does not change as we
index dc3f2c23ff23d32fa6ec75c4b6c3c57437a16e22..aac858b7aca616467073948f6fbdcdbfaf7b002a 100644 (file)
@@ -815,7 +815,7 @@ namespace Step22
       SolverCG<Vector<double>> cg(solver_control);
 
       // Now to the preconditioner to the Schur complement. As explained in
-      // the introduction, the preconditioning is done by a mass matrix in the
+      // the introduction, the preconditioning is done by a @ref GlossMassMatrix "mass matrix" in the
       // pressure variable.
       //
       // Actually, the solver needs to have the preconditioner in the form
index 0a77d03890801b3da2f787428565914143091c91..a0e5c7ce7e32909a097af5eaa40eab2c39235d96 100644 (file)
@@ -88,7 +88,7 @@ namespace Step23
   // Next comes the declaration of the main class. It's public interface of
   // functions is like in most of the other tutorial programs. Worth
   // mentioning is that we now have to store four matrices instead of one: the
-  // mass matrix $M$, the Laplace matrix $A$, the matrix $M+k^2\theta^2A$ used
+  // @ref GlossMassMatrix "mass matrix" $M$, the Laplace matrix $A$, the matrix $M+k^2\theta^2A$ used
   // for solving for $U^n$, and a copy of the mass matrix with boundary
   // conditions applied used for solving for $V^n$. Note that it is a bit
   // wasteful to have an additional copy of the mass matrix around. We will
index 694169dc9daecbaf874960ebf1c795fea480f9c1..b542c24450308b980960f6cb9574f954df5c1fe7 100644 (file)
@@ -95,7 +95,7 @@ namespace Step24
     unsigned int timestep_number;
     const double theta;
 
-    //  Here's what's new: first, we need that boundary mass matrix $B$ that
+    //  Here's what's new: first, we need that boundary @ref GlossMassMatrix "mass matrix" $B$ that
     //  came out of the absorbing boundary condition. Likewise, since this
     //  time we consider a realistic medium, we must have a measure of the
     //  wave speed $c_0$ that will enter all the formulas with the Laplace
index 3728cdf7e3c26727e6e6460e224fa6758264c0be..db22da07a2327c469777b46e291d78d8eda51a3b 100644 (file)
@@ -166,7 +166,7 @@ Above, the matrix $F_h'(\cdot)$ and the vector $F_h(\cdot)$ denote the discrete
 \f}
 Again, note that the first matrix equation above is, in fact, the
 definition of an iterative procedure, so it is solved multiple times
-until a stopping criterion is met. Moreover, $M$ is the mass matrix,
+until a stopping criterion is met. Moreover, $M$ is the @ref GlossMassMatrix "mass matrix",
 i.e. $M_{ij} = \left( \varphi_i,\varphi_j \right)_{\Omega}$, $A$ is
 the Laplace matrix, i.e. $A_{ij} = \left( \nabla \varphi_i, \nabla
 \varphi_j \right)_{\Omega}$, $S$ is the nonlinear term in the
index 84f6b5ce168de60dc6320f9cd7cf061f0ec46664..1a44f628f4cd2d3bd0a037f334a4de4fbb53a525 100644 (file)
@@ -75,7 +75,7 @@ $k_n$:
   \theta F^n
   \right],
 @f}
-where $M$ is the mass matrix and $A$ is the stiffness matrix that results from
+where $M$ is the @ref GlossMassMatrix "mass matrix" and $A$ is the stiffness matrix that results from
 discretizing the Laplacian. Bringing all known quantities to the right hand
 side yields the linear system we have to solve in every step:
 @f{align*}
index 9a828d8d3761707a584612a06bdbffb38eee5624..db8010651ff0fe20a03adb29e1c6d95c13949f10 100644 (file)
@@ -182,7 +182,7 @@ translated it to the following ones:
   &
   \theta k \left| a_{ij} \right| &\geq m_{ij},\qquad j \neq i,
 @f}
-where $M = m_{ij}$ denotes the mass matrix and $A = a_{ij}$ the stiffness
+where $M = m_{ij}$ denotes the @ref GlossMassMatrix "mass matrix" and $A = a_{ij}$ the stiffness
 matrix with $a_{ij} \leq 0$ for $j \neq i$, respectively. With
 $a_{ij} \leq 0$, we can formulate bounds for the global time step $k$ as
 follows:
index b2370b688bc15ee5f1817f4a034c7a6e30c488dc..7745ee3d6bed4d6bac80494e33c33638eb998a4f 100644 (file)
@@ -469,7 +469,7 @@ these three cases, as follows:
     = (B_c M_{K_c})^{ij} \phi_{g'}^j,
   @f}
   where $M_{K_c}^{lj}=\int_{K_c} f(x) \varphi_{g'}^l(x) \varphi_{g'}^j(x)$ is
-  the weighted mass matrix on child $c$ of cell $K$.
+  the weighted @ref GlossMassMatrix "mass matrix" on child $c$ of cell $K$.
 
   The next question is what happens if a child $K_c$ of $K$ is not
   active. Then, we have to apply the process recursively, i.e. we have to
index bf352854baff5e2f7703eb8026c4591343cbb007..290712b5b38cb82fc0f15ae97fc5ff560b91b60c 100644 (file)
@@ -842,7 +842,7 @@ namespace Step28
   {
     // The first case is that both cells are no further refined. In that case,
     // we can assemble the relevant terms (see the introduction). This
-    // involves assembling the mass matrix on the finer of the two cells (in
+    // involves assembling the @ref GlossMassMatrix "mass matrix" on the finer of the two cells (in
     // fact there are two mass matrices with different coefficients, one for
     // the fission distribution cross section $\chi_g\nu\Sigma_{f,g'}$ and one
     // for the scattering cross section $\Sigma_{s,g'\to g}$). This is
index 18e4c0281a7527fe2ec08993fce68f0bff27cb96..00b007449270e90ab1311a0d27397873b0ccea0c 100644 (file)
@@ -549,7 +549,7 @@ this yields for the simpler case of uniform time steps of size $k$:
 On the left side of this equation remains the term from the time
 derivative and the original (physical) diffusion which we treat
 implicitly (this is actually a nice term: the matrices that result
-from the left hand side are the mass matrix and a multiple of the
+from the left hand side are the @ref GlossMassMatrix "mass matrix" and a multiple of the
 Laplace matrix &mdash; both are positive definite and if the time step
 size $k$ is small, the sum is simple to invert). On the right hand
 side, the terms in the first line result from the time derivative; in
@@ -710,7 +710,7 @@ S^{-1}$ by a CG solver applied to the mass matrix on the pressure
 space was a good choice. In a small deviation from step-22, we
 here have a coefficient $\eta$ in the momentum equation, and by the same
 derivation as there we should arrive at the conclusion that it is the weighted
-mass matrix with entries $\tilde S_{ij}=(\eta^{-1}\varphi_i,\varphi_j)$ that
+@ref GlossMassMatrix "mass matrix" with entries $\tilde S_{ij}=(\eta^{-1}\varphi_i,\varphi_j)$ that
 we should be using.
 
 It was more complicated to come up with a good replacement $\tilde
index 6267d03ce525d07524b580be0cbc6085930daf8c..598378f45183db68ecc58d1940a60ba0d82a1d2e 100644 (file)
@@ -323,7 +323,7 @@ system matrix $M$ in block form such that the product matrix
 is of a form that Krylov-based iterative solvers like GMRES can solve in a
 few iterations. We then replaced the exact inverse of $A$ by the action
 of an AMG preconditioner $\tilde{A}$ based on a vector Laplace matrix,
-approximated the Schur complement $S = B A^{-1} B^T$ by a mass matrix $M_p$
+approximated the Schur complement $S = B A^{-1} B^T$ by a @ref GlossMassMatrix "mass matrix" $M_p$
 on the pressure space and wrote an <tt>InverseMatrix</tt> class for
 implementing the action of $M_p^{-1}\approx S^{-1}$ on vectors. In the
 InverseMatrix class, we used a CG solve with an incomplete Cholesky (IC)
index 3ac999509e672ec4cfcf578ec0f59ad50291f7c4..6e70d249e682e36e488f807258d6f36142cc73ae 100644 (file)
@@ -84,7 +84,7 @@ continuous eigenvalue problem: @f[ \sum_j [(\nabla\phi_i,
 matrix and vector notation, this equation then reads: @f[ A
 \tilde{\Psi} = \varepsilon_h M \tilde{\Psi} \quad, @f] where $A$ is
 the stiffness matrix arising from the differential operator $L$, and
-$M$ is the mass matrix. The solution to the eigenvalue problem is an
+$M$ is the @ref GlossMassMatrix "mass matrix". The solution to the eigenvalue problem is an
 eigenspectrum $\varepsilon_{h,\ell}$, with associated eigenfunctions
 $\Psi_\ell=\sum_j \phi_j\tilde{\psi}_j$.
 
index e97b6f4acf6c6e34fd96cab7e1cccbf717a42e26..fc5e4bbba970fc824c3d2569b3ac059757d857a7 100644 (file)
@@ -86,7 +86,7 @@ namespace Step36
     DoFHandler<dim>    dof_handler;
 
     // With these exceptions: For our eigenvalue problem, we need both a
-    // stiffness matrix for the left hand side as well as a mass matrix for
+    // stiffness matrix for the left hand side as well as a @ref GlossMassMatrix "mass matrix" for
     // the right hand side. We also need not just one solution function, but a
     // whole set of these for the eigenfunctions we want to compute, along
     // with the corresponding eigenvalues:
index 01cbf726dc470b6e45d91fb7859a6a07600d10c1..e9046008c2c17591bab81b0eaabe4a15f8b77184 100644 (file)
@@ -191,7 +191,7 @@ namespace Step37
   // parameter as is done in the MatrixFreeOperators::LaplaceOperator class.
   //
   // As a sidenote, if we implemented several different operations on the same
-  // grid and degrees of freedom (like a mass matrix and a Laplace matrix), we
+  // grid and degrees of freedom (like a @ref GlossMassMatrix "mass matrix" and a Laplace matrix), we
   // would define two classes like the current one for each of the operators
   // (derived from the MatrixFreeOperators::Base class), and let both of them
   // refer to the same MatrixFree data cache from the general problem
index bc0fefcee4cc06ceb6246c1e9d0a46ba990ded66..04eb08e134b127ddecd9294d3f558822af6051a1 100644 (file)
@@ -185,7 +185,7 @@ get the equations
  &[BU-G]_i \geq 0, \quad \Lambda_i \leq 0,\quad \Lambda_i[BU-G]_i = 0
 \qquad \forall i.&
 @f}
-where $B$ is the mass matrix on the chosen finite element space and the
+where $B$ is the @ref GlossMassMatrix "mass matrix" on the chosen finite element space and the
 indices $i$ above are for all degrees of freedom in the set $\cal S$ of degrees of
 freedom located in the interior of the domain
 (we have Dirichlet conditions on the perimeter). However, we
index 428d2b9e7768a03f24c20a0d50e888c6a7a10b56..1ba43c79de2cdd2b28a4a118deba5eb6b3a1ba47 100644 (file)
@@ -68,7 +68,7 @@ namespace Step41
   // (unconstrained) form of the linear system
   // (<code>complete_system_matrix</code> and
   // <code>complete_system_rhs</code>) as well as the active set itself and
-  // the diagonal of the mass matrix $B$ used in scaling Lagrange multipliers
+  // the diagonal of the @ref GlossMassMatrix "mass matrix" $B$ used in scaling Lagrange multipliers
   // in the active set formulation. The rest is as in step-4:
   template <int dim>
   class ObstacleProblem
index c83313f5a3e668b2098ce41ea838c13e260508bc..3ed82d1f3ede7f0dbb0969f08c2a44efc2736e1c 100644 (file)
@@ -1101,7 +1101,7 @@ namespace Step42
 
   // @sect4{PlasticityContactProblem::assemble_mass_matrix_diagonal}
 
-  // The next helper function computes the (diagonal) mass matrix that
+  // The next helper function computes the (diagonal) @ref GlossMassMatrix "mass matrix" that
   // is used to determine the active set of the active set method we use in
   // the contact algorithm. This matrix is of mass matrix type, but unlike
   // the standard mass matrix, we can make it diagonal (even in the case of
index c1c6b816db6d38bd3251ca04fcd30022f23c8f1c..2ec5bde432dda039f70a2ed12436f897d4df2837 100644 (file)
@@ -279,7 +279,7 @@ fully discrete problem at time step $n$:
 where $\mathbf{u}_t^{*}$ is the velocity linearly extrapolated from
 $\mathbf{u}^{(n_p)}_t$ and $\mathbf{u}^{(n_{pp})}_t$ to the current time $t^{(n)}$ if $\theta<\theta^*$ while $\mathbf{u}_t^{*}$ is $\mathbf{u}^{(n_p)}_t$ if $\theta>\theta^*$.
 Consequently, the equation is linear in $S_h^{(n)}$ and all that is required
-is to solve with a mass matrix on the saturation space.
+is to solve with a @ref GlossMassMatrix "mass matrix" on the saturation space.
 
 Since the Dirichlet boundary conditions for saturation are only imposed on the
 inflow boundaries, the third term on the left hand side of the equation above
index ee97b1bad157548f5632586a1a494d78edea7792..32aa62149b7ab2711a444690a924be22cadfe547 100644 (file)
@@ -794,7 +794,7 @@ namespace Step43
   // @sect4{TwoPhaseFlowProblem<dim>::assemble_darcy_preconditioner}
 
   // This function assembles the matrix we use for preconditioning the Darcy
-  // system. What we need are a vector mass matrix weighted by
+  // system. What we need are a vector @ref GlossMassMatrix "mass matrix" weighted by
   // $\left(\mathbf{K} \lambda_t\right)^{-1}$ on the velocity components and a
   // mass matrix weighted by $\left(\mathbf{K} \lambda_t\right)$ on the
   // pressure component. We start by generating a quadrature object of
index bd9a2f0bdc0760cb4ba0feb3cdd240b42fa91f1b..3bdcc8268eb0aebd7268c7ab212a11fd49777108 100644 (file)
@@ -21,7 +21,7 @@ solve nonlinear partial differential equations. Moreover, we have another look
 at the handling of constraints within the matrix-free framework.
 Finally, we will use an explicit time-stepping
 method to solve the problem and introduce Gauss-Lobatto finite elements that
-are very convenient in this case since their mass matrix can be accurately
+are very convenient in this case since their @ref GlossMassMatrix "mass matrix" can be accurately
 approximated by a diagonal, and thus trivially invertible, matrix. The two
 ingredients to this property are firstly a distribution of the nodal points of
 Lagrange polynomials according to the point distribution of the Gauss-Lobatto
index ee1e081444fe33281b74b8c30b253676bd3bd83b..13c47faeb371b649c0e1eab1ca53f7b9cc446061 100644 (file)
@@ -77,7 +77,7 @@ solved can be written as:
 \frac{dy}{dt} = g(t,y).
 @f}
 On the other hand, when using finite elements, discretized time derivatives always result in the
-presence of a mass matrix on the left hand side. This can easily be seen by
+presence of a @ref GlossMassMatrix "mass matrix" on the left hand side. This can easily be seen by
 considering that if the solution vector $y(t)$ in the equation above is in fact the vector
 of nodal coefficients $U(t)$ for a variable of the form
 @f{eqnarray*}
index 27fcbe78a974a8d36bdfbd8f0a41077d7c08ea8f..195f6cd366089a5da5a74c6a253764480ac288be 100644 (file)
@@ -184,7 +184,7 @@ namespace Step52
   // @sect4{<code>Diffusion::assemble_system</code>}
   // In this function, we compute $-\int D \nabla b_i \cdot \nabla b_j
   // d\boldsymbol{r} - \int \Sigma_a b_i b_j d\boldsymbol{r}$ and the mass
-  // matrix $\int b_i b_j d\boldsymbol{r}$. The mass matrix is then
+  // matrix $\int b_i b_j d\boldsymbol{r}$. The @ref GlossMassMatrix "mass matrix" is then
   // inverted using a direct solver; the <code>inverse_mass_matrix</code>
   // variable will then store the inverse of the mass matrix so that
   // $M^{-1}$ can be applied to a vector using the <code>vmult()</code>
index 08f31a2d57bc66e11e4a3bf152b99a94fa81dac0..4877a22847707ee6f87639402f2fd5caa6c88ef4 100644 (file)
@@ -136,7 +136,7 @@ great from the computational standpoint (simpler and cheaper
 than GMRES for example), and applicable (matrix and preconditioner are
 symmetric).
 
-For the approximations we will use a CG solve with the mass matrix in the
+For the approximations we will use a CG solve with the @ref GlossMassMatrix "mass matrix" in the
 pressure space for approximating the action of $S^{-1}$. Note that the mass
 matrix is spectrally equivalent to $S$. We can expect the number of CG
 iterations to be independent of $h$, even with a simple preconditioner like
index a0392ab99bea8e814553ce6fb23d352ee6ffff9f..683abb824f11bd7b8561c342c04043a49edb7c2f 100644 (file)
@@ -440,7 +440,7 @@ namespace Step55
     }
 
     // The preconditioner matrix has a different coupling (we only fill in
-    // the 1,1 block with the mass matrix), otherwise this code is identical
+    // the 1,1 block with the @ref GlossMassMatrix "mass matrix"), otherwise this code is identical
     // to the construction of the system_matrix above.
     {
       preconditioner_matrix.clear();
index 42250c4f23d87fbe87c72764de66779f3d62a7fc..ee002f95cc6fdb51c30f89c6d17599908d3a870f 100644 (file)
@@ -94,7 +94,7 @@ Since $P$ is aimed to be a preconditioner only, we shall use
 the approximations on the right in the equation above.
 
 As discussed in step-22, $-M_p^{-1}=:\widetilde{S^{-1}} \approx
-S^{-1}$, where $M_p$ is the pressure mass matrix and is solved approximately by using CG
+S^{-1}$, where $M_p$ is the pressure @ref GlossMassMatrix "mass matrix" and is solved approximately by using CG
 with ILU as a preconditioner, and $\widetilde{A^{-1}}$ is obtained by one of
 multiple methods: solving a linear system with CG and ILU as
 preconditioner, just using one application of an ILU, solving a linear
index abf7b38290dacfb6d14763b9279387b3c715308e..bda7a4a55c199d4cad6bc61c2ca8f2a6be53da7e 100644 (file)
@@ -596,7 +596,7 @@ namespace Step56
   // @sect4{StokesProblem::assemble_system}
 
   // In this function, the system matrix is assembled. We assemble the pressure
-  // mass matrix in the (1,1) block (if needed) and move it out of this location
+  // @ref GlossMassMatrix "mass matrix" in the (1,1) block (if needed) and move it out of this location
   // at the end of this function.
   template <int dim>
   void StokesProblem<dim>::assemble_system()
index 76b4fd629f36c8663186a44fcb68b04dd0bd2b53..8a7061145bdb00447217047c9f5d6abbe10a062c 100644 (file)
@@ -252,7 +252,7 @@ P^{-1} =
 
 with $\tilde{A} = A + \gamma B^TW^{-1}B$ and $\tilde{S}$ is the
 corresponding Schur complement $\tilde{S} = B^T \tilde{A}^{-1} B$. We
-let $W = M_p$ where $M_p$ is the pressure mass matrix, then
+let $W = M_p$ where $M_p$ is the pressure @ref GlossMassMatrix "mass matrix", then
 $\tilde{S}^{-1}$ can be approximated by
 @f{eqnarray*}
 \tilde{S}^{-1} \approx -(\nu+\gamma)M_p^{-1}.
index a2ee6bbd8b6778ddf10477548a9afae80d812a2d..b1cc6f04f16d057cdc57b027005f76c3298d6162 100644 (file)
@@ -179,7 +179,7 @@ namespace Step57
   // we solve this system via a direct solver for simplicity. The computation
   // involved in the second factor is a simple matrix-vector
   // multiplication. The Schur complement $\tilde{S}$ can be well approximated
-  // by the pressure mass matrix and its inverse can be obtained through an
+  // by the pressure @ref GlossMassMatrix "mass matrix" and its inverse can be obtained through an
   // inexact solver. Because the pressure mass matrix is symmetric and
   // positive definite, we can use CG to solve the corresponding linear
   // system.
index 0a24164ffad49f6c6c892d58101188d7545b77fb..980185edef25a21ad91d3d508273164783ac481c 100644 (file)
@@ -812,7 +812,7 @@ namespace Step59
     // we check that it is diagonal and then extract the determinant of the
     // original Jacobian, i.e., the inverse of the determinant of the inverse
     // Jacobian, and set the weight as $\text{det}(J) / h_d^2$ according to
-    // the 1d Laplacian times $d-1$ copies of the mass matrix.
+    // the 1d Laplacian times $d-1$ copies of the @ref GlossMassMatrix "mass matrix".
     cell_matrices.clear();
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(*data);
     unsigned int old_mapping_data_index = numbers::invalid_unsigned_int;
index 328e7f32e4afb06c8129bb0a0536084467e60445..04ab0a81f9f8065d886ece74185b86ba8a88f1d7 100644 (file)
@@ -304,7 +304,7 @@ and consequently
 @f}
 (In this last step, we have assumed that the indices $i,j,k$ only range
 over those degrees of freedom active on cell $K$,
-thereby ensuring that the mass matrix on the space $RT_s(K)$ is invertible.)
+thereby ensuring that the @ref GlossMassMatrix "mass matrix" on the space $RT_s(K)$ is invertible.)
 Equivalently, using the symmetry of the matrix $M$, we have that
 @f{equation*}{
   C^K = \left(G^K\right)^{T} \left(M^K\right)^{-1}.
index cdc222a750c179f7f822eba3e61aa28850bdbb8d..97f6b3c8088b1f2000f9c8d463824296c52cec38 100644 (file)
@@ -461,7 +461,7 @@ namespace Step61
         coefficient.value_list(fe_values.get_quadrature_points(),
                                coefficient_values);
 
-        // The first cell matrix we will compute is the mass matrix
+        // The first cell matrix we will compute is the @ref GlossMassMatrix "mass matrix"
         // for the Raviart-Thomas space.  Hence, we need to loop over
         // all the quadrature points for the velocity FEValues object.
         cell_matrix_M = 0;
index 41d86c57d79c6e52da652815fe7c6c2af9860c8d..3d31085566583c01b68194becafa2a0dbb9244b1 100644 (file)
@@ -911,7 +911,7 @@ namespace step62
                           const Tensor<2, dim> grad_phi_j =
                             fe_values[displacement].gradient(j, q);
 
-                          // calculate the values of the mass matrix.
+                          // calculate the values of the @ref GlossMassMatrix "mass matrix".
                           quadrature_data.mass_coefficient[i][j] =
                             rho_values[q] * xi * phi_i * phi_j;
 
index 0794bb9a3b72388d20571fd08c0284c5e382b21a..45688afd027375ab5ebcc6fae23c3bffabd47b41 100644 (file)
@@ -324,7 +324,7 @@ cells:
 where $\boldsymbol{\varphi}_i$ runs through all basis functions with from 1 to
 $n_\text{dofs}$.
 
-We now denote by $\mathcal M$ the mass matrix with entries $\mathcal M_{ij} =
+We now denote by $\mathcal M$ the @ref GlossMassMatrix "mass matrix" with entries $\mathcal M_{ij} =
 \sum_{K} \left(\boldsymbol{\varphi}_i,
 \boldsymbol{\varphi}_j\right)_K$, and by
 @f[
index 416d51fb6fd21702aa903a75c01fe4e6dcc3c513..15acd85da702baefe9aa9b8af5b3b8933dc83c38 100644 (file)
@@ -267,7 +267,7 @@ the (explicit time stepping) scheme as:
 @f}
 where
   - $m_i \dealcoloneq \int_{\Omega} \phi_i \, \mathrm{d}\mathbf{x}$
-    is the lumped mass matrix
+    is the lumped @ref GlossMassMatrix "mass matrix"
   - $\tau$ is the time step size
   - $\mathbf{c}_{ij} \dealcoloneq \int_{\Omega} \nabla\phi_j\phi_i \,
     \mathrm{d}\mathbf{x}$ (note that $\mathbf{c}_{ij}\in \mathbb{R}^d$)
index 018d6c22ac0f1e092d129127d9498e7d75a5a350..7e229edfa1d3a689a0377ba960effac904e31739 100644 (file)
@@ -178,7 +178,7 @@ namespace Step69
   //
   // The class <code>OfflineData</code> contains pretty much all components
   // of the discretization that do not evolve in time, in particular, the
-  // DoFHandler, SparsityPattern, boundary maps, the lumped mass matrix,
+  // DoFHandler, SparsityPattern, boundary maps, the lumped @ref GlossMassMatrix "mass matrix",
   // $\mathbf{c}_{ij}$ and $\mathbf{n}_{ij}$ matrices. Here, the term
   // <i>offline</i> refers to the fact that all the class
   // members of <code>OfflineData</code> have well-defined values
index 1d66c58db9e16eb1fe5969b6a8d1a4e82bb10966..98b375419c527c6e2d6758226f3e50e01f053bd2 100644 (file)
@@ -1527,7 +1527,7 @@ namespace Step70
   // This function solves the linear system with FGMRES with a block diagonal
   // preconditioner and an algebraic multigrid (AMG) method for the diagonal
   // blocks. The preconditioner applies a V cycle to the $(0,0)$ (i.e., the
-  // velocity-velocity) block and a CG with the mass matrix for the $(1,1)$
+  // velocity-velocity) block and a CG with the @ref GlossMassMatrix "mass matrix" for the $(1,1)$
   // block (which is our approximation to the Schur complement: the pressure
   // mass matrix assembled above).
   template <int dim, int spacedim>
index 1fb89ede07796cdb41344c6adb9990273c53a967..b7a894592e4742abff11c21a118d60edf8a8a736 100644 (file)
@@ -377,7 +377,7 @@ namespace BlackScholesSolver
 
   // The next function sets up the DoFHandler object, computes
   // the constraints, and sets the linear algebra objects to their correct
-  // sizes. We also compute the mass matrix here by calling a function from the
+  // sizes. We also compute the @ref GlossMassMatrix "mass matrix" here by calling a function from the
   // library. We will compute the other 3 matrices next, because these need to
   // be computed 'by hand'.
   //
index 6796fc041238fd68f4c965e3e13f446a795ecf8f..0cb3a32e20dac11bbad1d2979531bb011ae6fa05 100644 (file)
@@ -212,7 +212,7 @@ where $\{\psi_n\}_{n=1}^{N_c}$ and $\{\psi_n\}_{n=N_c+1}^{N_c+N_n}$ are the basi
 @f[
 M\boldsymbol{B}=\boldsymbol{G},
 @f]
-where the components of the (local) mass matrix and the right-hand side are given respectively by
+where the components of the (local) @ref GlossMassMatrix "mass matrix" and the right-hand side are given respectively by
 @f[
 M_{mn}\dealcoloneq\int_{\Omega}\psi_n:\psi_m \quad \mbox{and} \quad G_m\dealcoloneq\int_e\average{{\rm div}\, \psi_m}\cdot \mathbf{n}_e\jump{\varphi}, \qquad 1\leq m,n \leq N_c+N_n.
 @f]
index 961f3f841818f04cadbb75ee5ccca50d5176f913..4f15e589d2e4a4e24249b5e62719cf0fe5bea1d9 100644 (file)
@@ -91,7 +91,7 @@ namespace Step82
 
     // As indicated by its name, the function
     // <code>assemble_local_matrix()</code> is used for the assembly of the
-    // (local) mass matrix used to compute the two lifting terms (see the matrix
+    // (local) @ref GlossMassMatrix "mass matrix" used to compute the two lifting terms (see the matrix
     // $\boldsymbol{M}_c$ introduced in the introduction when describing the
     // computation of $b_e$). The function
     // <code>compute_discrete_hessians()</code> computes the required discrete
index cc7bf993937e8ea057cdcdf1ff1ac1d7ccac956a..fb3c441ab5ff9ed3be756a77e4d888e3ecb355ef 100644 (file)
@@ -76,7 +76,7 @@ namespace Algorithms
    *   M u_{n+1} + \theta k F(u_{n+1})  = M u_n - (1-\theta)k F(u_n).
    * @f]
    *
-   * Here, <i>M</i> is the mass matrix. We see, that the right hand side
+   * Here, <i>M</i> is the @ref GlossMassMatrix "mass matrix". We see, that the right hand side
    * amounts to an explicit Euler step with modified step size in weak form
    * (up to inversion of M). The left hand side corresponds to an implicit
    * Euler step with modified step size (right hand side given). Thus, the
@@ -410,7 +410,7 @@ namespace Algorithms
      * step size from explicit_data().
      *
      * Its return value is $ Mu+cF(u) $, where $u$ is the current state
-     * vector, $M$ the mass matrix, $F$ the operator in space and $c$ is the
+     * vector, $M$ the @ref GlossMassMatrix "mass matrix", $F$ the operator in space and $c$ is the
      * adjusted time step size $(1-\theta) \Delta t$.
      */
     SmartPointer<OperatorBase, ThetaTimestepping<VectorType>> op_explicit;
@@ -422,7 +422,7 @@ namespace Algorithms
      *
      * Its return value is the solution <i>u</i> of <i>Mu-cF(u)=f</i>, where
      * <i>f</i> is the dual space vector found in the "Previous time" entry of
-     * the input data, <i>M</i> the mass matrix, <i>F</i> the operator in
+     * the input data, <i>M</i> the @ref GlossMassMatrix "mass matrix", <i>F</i> the operator in
      * space and <i>c</i> is the adjusted time step size $ \theta \Delta t$
      */
     SmartPointer<OperatorBase, ThetaTimestepping<VectorType>> op_implicit;
index 26caf22d993690eb3109d8ea7dde960fe30e1f1c..ad8d140e18e043c04430cb5e18eacccde605f74d 100644 (file)
@@ -661,7 +661,7 @@ namespace Polynomials
    * for <code>degree=2</code> are $p_0(x)=(1-x)^2$, $p_1(x)=2x(x-1)$, and
    * $p_2(x)=x^2$, in accordance with the construction principle for degree 3.
    *
-   * These two relaxations improve the condition number of the mass matrix
+   * These two relaxations improve the condition number of the @ref GlossMassMatrix "mass matrix"
    * (i.e., interpolation) significantly, as can be seen from the following
    * table:
    *
index 2927a841d95042563c7c1e56a6f921ac1b092016..95b4d1a9613eceebebac7eba7a56ab7468955dc7 100644 (file)
@@ -345,7 +345,7 @@ namespace parallel
      * to the continuous space defined by a single FiniteElement @p projection_fe .
      * This is achieved using
      * FETools::compute_projection_from_quadrature_points_matrix(). In  doing so
-     * the mass matrix of this element is required, which will be calculated
+     * the @ref GlossMassMatrix "mass matrix" of this element is required, which will be calculated
      * with the @p mass_quadrature rule . Should the cell now belong to another processor,
      * the data is then sent to this processor. The class makes use of a feature
      * of p4est (and parallel::distributed::Triangulation) that allows one to
@@ -451,7 +451,7 @@ namespace parallel
 
       /**
        * Constructor which takes the FiniteElement @p projection_fe , the quadrature
-       * rule @p mass_quadrature used to integrate its local mass matrix and
+       * rule @p mass_quadrature used to integrate its local @ref GlossMassMatrix "mass matrix" and
        * finally the quadrature rule @p data_quadrature which is used to store @p DataType.
        *
        * @pre @p projection_fe has to be scalar-valued.
index 56992386fbaa7182c9785d40a07dd04c3c1843f5..a2431e8ecedf20062e07f2019e2ed2db42cfddaa 100644 (file)
@@ -134,7 +134,7 @@ namespace DoFTools
  * With this vector, one can get, for any given degree of freedom, a unique
  * number among those DoFs that sit on the boundary; or, if your DoF was
  * interior to the domain, the result would be numbers::invalid_dof_index.
- * We need this mapping, for example, to build the mass matrix on the boundary
+ * We need this mapping, for example, to build the @ref GlossMassMatrix "mass matrix" on the boundary
  * (for this, see make_boundary_sparsity_pattern() function, the corresponding
  * section below, as well as the MatrixCreator namespace documentation).
  *
index c74cebcbe183e92bafa92b7cfe9d96eac12176f1..4c026b9fd2ca52593c5941c40e38089d92714e99 100644 (file)
@@ -46,7 +46,7 @@ DEAL_II_NAMESPACE_OPEN
  * necessarily on the real cell). As a consequence, the first basis function
  * of this element is always the function that is constant and equal to one,
  * regardless of the polynomial degree of the element. In addition, as a
- * result of the orthogonality of the basis functions, the mass matrix is
+ * result of the orthogonality of the basis functions, the @ref GlossMassMatrix "mass matrix" is
  * diagonal if the grid cells are parallelograms. Note that this is in
  * contrast to the FE_DGPMonomial class that actually uses the monomial basis
  * listed above as basis functions, without transformation from reference to
index 9cd3527651fbcf6c6317c2c56eecef99fa3a8bcb..8b8deb3fd33d736482f9fe60c175af4a10011c3e 100644 (file)
@@ -43,7 +43,7 @@ DEAL_II_NAMESPACE_OPEN
  * The basis functions for this element are chosen to be the monomials listed
  * above. Note that this is the main difference to the FE_DGP class that uses
  * a set of polynomials of complete degree <code>p</code> that form a Legendre
- * basis on the unit square. Thus, there, the mass matrix is diagonal, if the
+ * basis on the unit square. Thus, there, the @ref GlossMassMatrix "mass matrix" is diagonal, if the
  * grid cells are parallelograms. The basis here does not have this property;
  * however, it is simpler to compute. On the other hand, this element has the
  * additional disadvantage that the local cell matrices usually have a worse
index 012c82643b5fabfa96ce558d44ccffdf84647b36..16a72cc938de0f73cf74fff019a9bcda56f405c6 100644 (file)
@@ -100,7 +100,7 @@ class Quadrature;
  * increases. In interpolation, this effect is known as the Runge
  * phenomenon. For Galerkin methods, the Runge phenomenon is typically not
  * visible in the solution quality but rather in the condition number of the
- * associated system matrices. For example, the elemental mass matrix of
+ * associated system matrices. For example, the elemental @ref GlossMassMatrix "mass matrix" of
  * equidistant points at degree 10 has condition number 2.6e6, whereas the
  * condition number for Gauss-Lobatto points is around 400.
  *
@@ -386,7 +386,7 @@ private:
 /**
  * Implementation of scalar, discontinuous tensor product elements based on
  * Lagrange polynomials with arbitrary nodes. The primary purpose of this
- * class is to provide an element for which the mass matrix can be made
+ * class is to provide an element for which the @ref GlossMassMatrix "mass matrix" can be made
  * diagonal by choosing basis functions that are not either zero or one at the
  * vertices of the cell, but instead are zero or one at a given set of
  * quadrature points. If this set of quadrature points is then also used in
index db89e4d674d517e173471aa6552ad4c9b4c706c8..3766f9708ef7e0eb3702eb2017fbf37d911053df 100644 (file)
@@ -75,7 +75,7 @@ DEAL_II_NAMESPACE_OPEN
  * increases. In interpolation, this effect is known as the Runge
  * phenomenon. For Galerkin methods, the Runge phenomenon is typically not
  * visible in the solution quality but rather in the condition number of the
- * associated system matrices. For example, the elemental mass matrix of
+ * associated system matrices. For example, the elemental @ref GlossMassMatrix "mass matrix" of
  * equidistant points at degree 10 has condition number 2.6e6, whereas the
  * condition number for Gauss-Lobatto points is around 400.
  *
@@ -577,7 +577,7 @@ public:
    * different are the basis functions of this space. This is useful in
    * contexts where one wants to achieve certain properties of the matrices
    * that result from integrating bilinear forms of these shape functions.
-   * For example, when computing the mass matrix on cell $K$,
+   * For example, when computing the @ref GlossMassMatrix "mass matrix" on cell $K$,
    * @f[
    *   M_{ij}^K = \int_K \varphi_i(\mathbf x) \varphi_j(\mathbf x) \; dx
    * @f]
index 566fcdb609a0adac41d045117d34669c9bf18736..b2b8ae40d569c24a743b9030b2eb644349ff68ba 100644 (file)
@@ -37,7 +37,7 @@ DEAL_II_NAMESPACE_OPEN
  * vector fields with normal components continuous between mesh cells. The
  * purpose of this finite element is in localizing the interactions
  * between degrees of freedom around the nodes when an appropriate quadrature
- * rule is used, leading to a block-diagonal mass matrix (even with full-tensor
+ * rule is used, leading to a block-diagonal @ref GlossMassMatrix "mass matrix" (even with full-tensor
  * coefficient).
  *
  * The elements are defined through enrichment of classical Raviart-Thomas
index b3a05e813ded6a028acbeea393fec4481e4e26ad..f825f30e7ecb743412c52c6b7df62bf11fd12956 100644 (file)
@@ -28,7 +28,7 @@ DEAL_II_NAMESPACE_OPEN
  * @brief Enriched version of FE_SimplexP that can be used with nodal
  * quadrature.
  *
- * Many explicit time integration schemes require solving a mass matrix at
+ * Many explicit time integration schemes require solving a @ref GlossMassMatrix "mass matrix" at
  * each time step. There are various ways around this requirement - for
  * example, step-48 replaces the mass matrix with a diagonal approximation,
  * which makes the solution step trivial. In step-48, and also commonly for
index b62f549df825388b178148362c393ace3c5ba1bf..1593407b8ce0161fd4abdecf649514eefb47cb9f 100644 (file)
@@ -456,7 +456,7 @@ namespace FETools
    * After these quadrature approximations, we end up with a nodal
    * representation <tt>V<sub>h</sub></tt> of <tt>v<sub>h</sub></tt> that
    * satisfies the following system of linear equations: <tt>M V<sub>h</sub> =
-   * Q U</tt>, where <tt>M<sub>ij</sub>=(phi_i,phi_j)</tt> is the mass matrix
+   * Q U</tt>, where <tt>M<sub>ij</sub>=(phi_i,phi_j)</tt> is the @ref GlossMassMatrix "mass matrix"
    * approximated by <tt>lhs_quadrature</tt>, and <tt>Q</tt> is the matrix
    * <tt>Q<sub>iq</sub>=phi<sub>i</sub>(x<sub>q</sub>) w<sub>q</sub></tt>
    * where <tt>w<sub>q</sub></tt> are quadrature weights; <tt>U</tt> is the
@@ -766,7 +766,7 @@ namespace FETools
    *
    * The global projection can be computed by local matrices if the finite
    * element spaces are discontinuous. With continuous elements, this is
-   * impossible, since a global mass matrix must be inverted.
+   * impossible, since a global @ref GlossMassMatrix "mass matrix" must be inverted.
    */
   template <int dim, class InVector, class OutVector, int spacedim>
   void
index fe7b8060ca9525c0895d4758ef332ccce45ae948..9eeeb00059f030f7a2741443f173b3c3e670b53c 100644 (file)
@@ -41,7 +41,7 @@ namespace LocalIntegrators
   namespace L2
   {
     /**
-     * The mass matrix for scalar or vector values finite elements. \f[ \int_Z
+     * The @ref GlossMassMatrix "mass matrix" for scalar or vector values finite elements. \f[ \int_Z
      * uv\,dx \quad \text{or} \quad \int_Z \mathbf u\cdot \mathbf v\,dx \f]
      *
      * Likewise, this term can be used on faces, where it computes  the
@@ -89,7 +89,7 @@ namespace LocalIntegrators
     }
 
     /**
-     * The weighted mass matrix for scalar or vector values finite elements.
+     * The weighted @ref GlossMassMatrix "mass matrix" for scalar or vector values finite elements.
      * \f[ \int_Z \omega(x) uv\,dx \quad \text{or} \quad \int_Z \omega(x)
      * \mathbf u\cdot \mathbf v\,dx \f]
      *
index 5f6f8ba9bb903f7e605d14ae1ceb92a419cc9c4e..96b049efece237a69bcd2b7bc69947de2ec386bf 100644 (file)
@@ -122,7 +122,7 @@ DEAL_II_NAMESPACE_OPEN
  * <li> 0: The vector Laplacian for the velocity (here with a vector valued
  * element)
  * <li> 1: The divergence matrix
- * <li> 2: The pressure mass matrix used in the preconditioner
+ * <li> 2: The pressure @ref GlossMassMatrix "mass matrix" used in the preconditioner
  * </ul>
  *
  * With these matrices, the function called by MeshWorker::loop() could be
index de87b6c8fd88d6b6572e23a3f4014df641075cc7..e94b9a45b62fa5a8145421dc2f6421ecb57dfcdc 100644 (file)
@@ -129,7 +129,7 @@ dseupd_(int *         rvec,
  *
  * In this class we make use of the method applied to the generalized
  * eigenspectrum problem $(A-\lambda B)x=0$, for $x\neq0$; where $A$ is a
- * system matrix, $B$ is a mass matrix, and $\lambda, x$ are a set of
+ * system matrix, $B$ is a @ref GlossMassMatrix "mass matrix", and $\lambda, x$ are a set of
  * eigenvalues and eigenvectors respectively.
  *
  * The ArpackSolver can be used in application codes with serial objects in
@@ -301,7 +301,7 @@ public:
    * this parameter is entirely unused.
    *
    * @param B The inner product of the underlying space, typically the mass
-   * matrix. For constrained problems, it can be a partial mass matrix, like
+   * matrix. For constrained problems, it can be a partial @ref GlossMassMatrix "mass matrix", like
    * for instance the velocity mass matrix of a Stokes problem. Only its
    * function <code>vmult()</code> is used.
    *
index 787c0a5a5e9245d4ba118bab149778e03bc10fe0..eb9ccd195e579946105bc6221e6ebfe1724004ff 100644 (file)
@@ -688,7 +688,7 @@ public:
    * Return the norm of the vector <i>v</i> with respect to the norm induced
    * by this matrix, i.e. <i>v<sup>T</sup>Mv)</i>. This is useful, e.g. in the
    * finite element context, where the <i>L<sup>T</sup></i>-norm of a function
-   * equals the matrix norm with respect to the mass matrix of the vector
+   * equals the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector
    * representing the nodal values of the finite element function. Note that
    * even though the function's name might suggest something different, for
    * historic reasons not the norm but its square is returned, as defined
index 8e7829426e0ad0c2ecf88dba3f47dd6740e06ea0..b214c8ddfa595da640bcf78d732a89bde85f798e 100644 (file)
@@ -953,7 +953,7 @@ public:
    * Return the square of the norm of the vector $v$ with respect to the norm
    * induced by this matrix, i.e. $\left(v,Mv\right)$. This is useful, e.g. in
    * the finite element context, where the $L_2$ norm of a function equals the
-   * matrix norm with respect to the mass matrix of the vector representing
+   * matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector representing
    * the nodal values of the finite element function.
    *
    * Obviously, the matrix needs to be quadratic for this operation, and for
index da735bf9ec9e87dea6af0f11eb950ac16b4f587d..266afa2608e09140177651b6095ca1e81a28cbf1 100644 (file)
@@ -253,7 +253,7 @@ namespace CUDAWrappers
      * Return the square of the norm of the vector $v$ with respect to the
      * norm induced by this matrix, i.e., $\left(v,Mv\right)$. This is useful,
      * e.g., in the finite context, where the $L_2$ norm of a function equals
-     * the matrix norm with respect to the mass matrix of the vector
+     * the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector
      * representing the nodal values of the finite element function.
      *
      * Obviously, the matrix needs to be quadratic for this operation.
index ee50fb8da4a1b7d337ddf473c22b497e286ddd60..462571b9bb9f7ee323fa326c521f1c1ebd075589 100644 (file)
@@ -401,7 +401,7 @@ public:
    * Return the square of the norm of the vector <tt>v</tt> induced by this
    * matrix, i.e. <i>(v,Mv)</i>. This is useful, e.g. in the finite element
    * context, where the <i>L<sup>2</sup></i> norm of a function equals the
-   * matrix norm with respect to the mass matrix of the vector representing
+   * matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector representing
    * the nodal values of the finite element function.
    *
    * Obviously, the matrix needs to be quadratic for this operation, and for
index 9e5acf9e0441350450dbb607c46fea71f34eb086..60b56c55ec949c146c1c8d566d389ff5252259ae 100644 (file)
@@ -65,7 +65,7 @@ namespace internal
  * different blocks in a block system. For example, a preconditioner for the
  * Oseen system can be built as a block system, where the pressure block is of
  * the form <b>M</b><sup>-1</sup><b>FA</b><sup>-1</sup> with <b>M</b> the
- * pressure mass matrix, <b>A</b> the pressure Laplacian and <b>F</b> the
+ * pressure @ref GlossMassMatrix "mass matrix", <b>A</b> the pressure Laplacian and <b>F</b> the
  * advection diffusion operator applied to the pressure space. Since only a
  * single matrix is needed for the other blocks, using BlockSparseMatrix or
  * similar would be a waste of memory.
index f111a07bf309b7351d7085070eeddfbb17f51ad0..99ef5fb0ad810bcbe406eb49b0c53c01d3c88e12 100644 (file)
@@ -145,7 +145,7 @@ extern "C"
  *
  * In this class we make use of the method applied to the generalized
  * eigenspectrum problem $(A-\lambda B)x=0$, for $x\neq0$; where $A$ is a
- * system matrix, $B$ is a mass matrix, and $\lambda, x$ are a set of
+ * system matrix, $B$ is a @ref GlossMassMatrix "mass matrix", and $\lambda, x$ are a set of
  * eigenvalues and eigenvectors respectively.
  *
  * The ArpackSolver can be used in application codes in the following way:
index 99363019e9efa0e8bcca5a8ba8eda96b75c47f99..215f8a0c8cfe45b064da57d242a4349a3f2fea56 100644 (file)
@@ -731,7 +731,7 @@ namespace PETScWrappers
      * Return the square of the norm of the vector $v$ with respect to the
      * norm induced by this matrix, i.e. $\left(v,Mv\right)$. This is useful,
      * e.g. in the finite element context, where the $L_2$ norm of a function
-     * equals the matrix norm with respect to the mass matrix of the vector
+     * equals the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector
      * representing the nodal values of the finite element function.
      *
      * Obviously, the matrix needs to be quadratic for this operation.
index 38840dd53a5672fb4cd21e73dbc00d38c6927d40..e1a96ffa7a9efededfab0ed72f7462930b2e78a5 100644 (file)
@@ -557,7 +557,7 @@ namespace PETScWrappers
        * Return the square of the norm of the vector $v$ with respect to the
        * norm induced by this matrix, i.e. $\left(v^\ast,Mv\right)$. This is
        * useful, e.g. in the finite element context, where the $L_2$ norm of a
-       * function equals the matrix norm with respect to the mass matrix of
+       * function equals the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of
        * the vector representing the nodal values of the finite element
        * function.
        *
index 187a11e6349e47c5cd29927e9a1a14650475d55a..adcb4b4f88537a63678dc535fe0e1153b3e884d3 100644 (file)
@@ -176,7 +176,7 @@ DEAL_II_NAMESPACE_OPEN
  * A better preconditioner in such a case would be one that provides a more
  * representative approximation for $ S^{-1} $. One approach is shown in
  * step-22, where $ D $ is the null matrix and the preconditioner for $ S^{-1}
- * $ is derived from the mass matrix over this space.
+ * $ is derived from the @ref GlossMassMatrix "mass matrix" over this space.
  *
  * From another viewpoint, a similar result can be achieved by first
  * constructing an object that represents an approximation for $ S $ wherein
index 65ef9f87a223e75e395822dc651d95969bdcc5bc..e8665d9f6bf8e5a86247f6cf6d205dc4b88262ea 100644 (file)
@@ -41,7 +41,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * The SLEPc solvers are intended to be used for solving the generalized
  * eigenspectrum problem $(A-\lambda B)x=0$, for $x\neq0$; where $A$ is a
- * system matrix, $B$ is a mass matrix, and $\lambda, x$ are a set of
+ * system matrix, $B$ is a @ref GlossMassMatrix "mass matrix", and $\lambda, x$ are a set of
  * eigenvalues and eigenvectors respectively. The emphasis is on methods and
  * techniques appropriate for problems in which the associated matrices are
  * sparse. Most of the methods offered by the SLEPc library are projection
index 248007e9c7ce9f7c2e968b8ffa3cec072f0605f8..dd6144b38e5cded223b0d524e5bc6c012514d41f 100644 (file)
@@ -1197,7 +1197,7 @@ public:
    * Return the square of the norm of the vector $v$ with respect to the norm
    * induced by this matrix, i.e. $\left(v,Mv\right)$. This is useful, e.g. in
    * the finite element context, where the $L_2$ norm of a function equals the
-   * matrix norm with respect to the mass matrix of the vector representing
+   * matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector representing
    * the nodal values of the finite element function.
    *
    * Obviously, the matrix needs to be quadratic for this operation, and for
index 7a4da66e0c97b5e06ef22205d43cb25828ecd89b..fdf96c24d9216fcae2a20ef6b2e462c5d1b36f93 100644 (file)
@@ -51,7 +51,7 @@ class FullMatrix;
  * @f}
  * in 3d. The typical application setting is a discretization of the Laplacian
  * $L$ on a Cartesian (axis-aligned) geometry, where it can be exactly
- * represented by the Kronecker or tensor product of a 1d mass matrix $M$ and
+ * represented by the Kronecker or tensor product of a 1d @ref GlossMassMatrix "mass matrix" $M$ and
  * a 1d Laplace matrix $A$ in each tensor direction (due to symmetry $M$ and $A$
  * are the same in each dimension). The dimension of the resulting class is the
  * product of the one-dimensional matrices.
@@ -155,7 +155,7 @@ public:
    * @warning This class accepts the following types:
    * "std::array<Table<2, Number>, dim>", "std::array<FullMatrix<Number>, dim>",
    * and "Table<2, Number>". In the latter case, we consider the same 1d
-   * mass matrix @p mass_matrix and the same 1d derivative matrix
+   * @ref GlossMassMatrix "mass matrix" @p mass_matrix and the same 1d derivative matrix
    * @p derivative_matrix for each tensor direction.
    */
   template <typename T>
@@ -239,7 +239,7 @@ public:
 
 protected:
   /**
-   * An array containing a mass matrix for each tensor direction.
+   * An array containing a @ref GlossMassMatrix "mass matrix" for each tensor direction.
    */
   std::array<Table<2, Number>, dim> mass_matrix;
 
@@ -343,7 +343,7 @@ namespace internal
  * A class similar to TensorProductMatrixSymmetricSum.
  *
  * The class TensorProductMatrixSymmetricSum stores a
- * 1d mass matrix, 1d stiffness matrix, eigenvalues and eigenvectors
+ * 1d @ref GlossMassMatrix "mass matrix", 1d stiffness matrix, eigenvalues and eigenvectors
  * for each direction. If one uses one TensorProductMatrixSymmetricSum
  * instance for, e.g., each cell, these quantities are stored
  * for each cell. There is no possibility to reuse quantities between
index aa513061dcf1439fe3665cd2d97ab754231d94d0..2a0639c7e192f94a988f484966851f197c07c30d 100644 (file)
@@ -190,7 +190,7 @@ public:
    * Return the square of the norm of the vector <tt>v</tt> with respect to
    * the norm induced by this matrix, i.e. <i>(v,Mv)</i>. This is useful, e.g.
    * in the finite element context, where the <i>L<sup>2</sup></i> norm of a
-   * function equals the matrix norm with respect to the mass matrix of the
+   * function equals the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the
    * vector representing the nodal values of the finite element function.
    *
    * Obviously, the matrix needs to be quadratic for this operation.
index 310ba946eef41d3fc1aeef0feaec9eca16fd6894..23ff3ade0bb2fd593c16efbc960e3e72b51c4bad 100644 (file)
@@ -1513,7 +1513,7 @@ namespace TrilinosWrappers
      * Return the square of the norm of the vector $v$ with respect to the
      * norm induced by this matrix, i.e., $\left(v,Mv\right)$. This is useful,
      * e.g. in the finite element context, where the $L_2$ norm of a function
-     * equals the matrix norm with respect to the mass matrix of the vector
+     * equals the matrix norm with respect to the @ref GlossMassMatrix "mass matrix" of the vector
      * representing the nodal values of the finite element function.
      *
      * Obviously, the matrix needs to be quadratic for this operation.
index 73355187f95511b65a7ca56a571b43551d6f473d..da52686722be4ab040f02c29571ee2277d3d96ed 100644 (file)
@@ -5580,7 +5580,7 @@ namespace internal
 
 
   /**
-   * This struct implements the action of the inverse mass matrix operation
+   * This struct implements the action of the inverse @ref GlossMassMatrix "mass matrix" operation
    * using an FEEvaluationData argument.
    */
   template <int dim, typename Number>
@@ -5697,7 +5697,7 @@ namespace internal
 
 
   /**
-   * This struct implements the action of the inverse mass matrix operation
+   * This struct implements the action of the inverse @ref GlossMassMatrix "mass matrix" operation
    * using an FEEvaluationData argument.
    */
   template <int dim, typename Number>
@@ -5784,7 +5784,7 @@ namespace internal
 
 
   /**
-   * This struct implements the action of the inverse mass matrix operation
+   * This struct implements the action of the inverse @ref GlossMassMatrix "mass matrix" operation
    * using an FEEvaluationData argument.
    */
   template <int dim, typename Number>
index b3e1f86d576d27fd5a0e10633221e436df7d3853..8b5dfce8a474dfaf38970b1bbdee25b75dc693b4 100644 (file)
@@ -598,7 +598,7 @@ namespace MatrixFreeOperators
 
   /**
    * This class implements the operation of the action of the inverse of a
-   * mass matrix on an element for the special case of an evaluation object
+   * @ref GlossMassMatrix "mass matrix" on an element for the special case of an evaluation object
    * with as many quadrature points as there are cell degrees of freedom. It
    * uses algorithms from FEEvaluation and produces the exact mass matrix for
    * DGQ elements. This algorithm uses tensor products of inverse 1d shape
@@ -637,7 +637,7 @@ namespace MatrixFreeOperators
                              VectorizedArrayType> &fe_eval);
 
     /**
-     * Applies the inverse mass matrix operation on an input array. It is
+     * Applies the inverse @ref GlossMassMatrix "mass matrix" operation on an input array. It is
      * assumed that the passed input and output arrays are of correct size,
      * namely FEEvaluation::dofs_per_cell long. The inverse of the
      * local coefficient (also containing the inverse JxW values) must be
@@ -651,7 +651,7 @@ namespace MatrixFreeOperators
           VectorizedArrayType *                     out_array) const;
 
     /**
-     * Applies the inverse mass matrix operation on an input array, using the
+     * Applies the inverse @ref GlossMassMatrix "mass matrix" operation on an input array, using the
      * inverse of the JxW values provided by the `fe_eval` argument passed to
      * the constructor of this class. Note that the user code must call
      * FEEvaluation::reinit() on the underlying evaluator to make the
@@ -726,7 +726,7 @@ namespace MatrixFreeOperators
 
 
   /**
-   * This class implements the operation of the action of a mass matrix.
+   * This class implements the operation of the action of a @ref GlossMassMatrix "mass matrix".
    *
    * @note This class only supports the non-blocked vector variant of the
    * Base operator because only a single FEEvaluation object is used in the
@@ -766,7 +766,7 @@ namespace MatrixFreeOperators
     compute_diagonal() override;
 
     /**
-     * Compute the lumped mass matrix. This is equal to the mass matrix times a
+     * Compute the lumped @ref GlossMassMatrix "mass matrix". This is equal to the mass matrix times a
      * vector of all ones and is equivalent to approximating the mass matrix
      * with a nodal quadrature rule.
      *
@@ -797,7 +797,7 @@ namespace MatrixFreeOperators
 
   private:
     /**
-     * Applies the mass matrix operation on an input vector. It is
+     * Applies the @ref GlossMassMatrix "mass matrix" operation on an input vector. It is
      * assumed that the passed input and output vector are correctly initialized
      * using initialize_dof_vector().
      */
index a00b00ef71cf644291c9f26b758cccc181e66e36..489fa6adb605cbdc33e8aaa6bb30954e3dd4da6c 100644 (file)
@@ -131,7 +131,7 @@ namespace NonMatching
 
 
   /**
-   * Create a coupling mass matrix for non-matching, overlapping grids.
+   * Create a coupling @ref GlossMassMatrix "mass matrix" for non-matching, overlapping grids.
    *
    * Given two non-matching triangulations, representing the domains $\Omega$
    * and $B$, with $B \subseteq \Omega$, and two finite element spaces
@@ -276,7 +276,7 @@ namespace NonMatching
     const ComponentMask &            comps1       = ComponentMask());
 
   /**
-   * Create a coupling mass matrix for non-matching independent grids,
+   * Create a coupling @ref GlossMassMatrix "mass matrix" for non-matching independent grids,
    * using a convolution kernel with compact support.
    *
    * Given two non-matching triangulations, representing the domains
index ade18e8b2023ca752e2c2c2151953b2940ea9c18..abb6ed35ae7097786dd96a180cbc9c0f207019d9 100644 (file)
@@ -135,7 +135,7 @@ namespace hp
  * the coefficient @p a, as well as the degree of the given @p Mapping (if
  * any).
  *
- * Note, that for vector-valued elements the mass matrix and the laplace
+ * Note, that for vector-valued elements the @ref GlossMassMatrix "mass matrix" and the laplace
  * matrix is implemented in such a way that each component couples only with
  * itself, i.e. there is no coupling of shape functions belonging to different
  * components. If the degrees of freedom have been sorted according to their
@@ -195,7 +195,7 @@ namespace hp
 namespace MatrixCreator
 {
   /**
-   * Assemble the mass matrix. If no coefficient is given (i.e., if the
+   * Assemble the @ref GlossMassMatrix "mass matrix". If no coefficient is given (i.e., if the
    * pointer to a function object is zero as it is by default), the
    * coefficient is taken as being constant and equal to one.
    * In case you want to specify @p constraints and use the default argument
@@ -241,7 +241,7 @@ namespace MatrixCreator
       constraints = AffineConstraints<typename SparseMatrixType::value_type>());
 
   /**
-   * Assemble the mass matrix and a right hand side vector. If no coefficient
+   * Assemble the @ref GlossMassMatrix "mass matrix" and a right hand side vector. If no coefficient
    * is given (i.e., if the pointer to a function object is zero as it is by
    * default), the coefficient is taken as being constant and equal to one.
    * In case you want to specify @p constraints and use the default argument
@@ -354,7 +354,7 @@ namespace MatrixCreator
 
 
   /**
-   * Assemble the mass matrix and a right hand side vector along the boundary.
+   * Assemble the @ref GlossMassMatrix "mass matrix" and a right hand side vector along the boundary.
    *
    * The matrix is assumed to already be initialized with a suiting sparsity
    * pattern (the DoFHandler provides an appropriate function).
index d17e1710c16f874c4ee2d30cafbd8d2ea302ba20..4589205bae31ecd380cf7d2561db96d29209fb34 100644 (file)
@@ -54,7 +54,7 @@ namespace TensorProductMatrixCreator
   };
 
   /**
-   * Create 1d mass matrix and 1d derivative matrix for a scalar
+   * Create 1d @ref GlossMassMatrix "mass matrix" and 1d derivative matrix for a scalar
    * constant-coefficient
    * Laplacian for a @p dim dimensional Cartesian cell. Its boundary types
    * can be specified with @p boundary_ids. The cell extent (including the cell extent
index 85738aef45b4f328e2cfa559fd12e2c99e9434f1..5751f1de2e425fef79ac227fd091a2c4ae845b7e 100644 (file)
@@ -81,7 +81,7 @@ DEAL_II_NAMESPACE_OPEN
  * (<i>f<sub>h</sub></i>,<i>v<sub>h</sub></i>)=(<i>f</i>,<i>v<sub>h</sub></i>)
  * for all discrete test functions <i>v<sub>h</sub></i>. This is done through
  * the solution of the linear system of equations <i> M v = f</i> where
- * <i>M</i> is the mass matrix $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$
+ * <i>M</i> is the @ref GlossMassMatrix "mass matrix" $m_{ij} = \int_\Omega \phi_i(x) \phi_j(x) dx$
  * and $f_i = \int_\Omega f(x) \phi_i(x) dx$. The solution vector $v$ then is
  * the nodal representation of the projection <i>f<sub>h</sub></i>. The
  * project() functions are used in the step-21 and step-23 tutorial programs.
@@ -204,7 +204,7 @@ DEAL_II_NAMESPACE_OPEN
  * The projection takes place on all boundary parts with boundary indicators
  * listed in the map (std::map<types::boundary_id, const
  * Function<spacedim,number>*>) of boundary functions. These boundary parts may
- * or may not be continuous. For these boundary parts, the mass matrix is
+ * or may not be continuous. For these boundary parts, the @ref GlossMassMatrix "mass matrix" is
  * assembled using the MatrixTools::create_boundary_mass_matrix() function, as
  * well as the appropriate right hand side. Then the resulting system of
  * equations is solved using a simple CG method (without preconditioning), which
index 50a724aefd8d7800fde804386678e2d6274ac4ee..117c201fc0e8c16e44f06dce06eca50e083f33eb 100644 (file)
@@ -399,7 +399,7 @@ namespace VectorTools
    * The projection happens on only those parts of the boundary whose
    * indicators are represented in this map.
    * @param[in] q The face quadrature used in the integration necessary to
-   * compute the mass matrix and right hand side of the projection.
+   * compute the @ref GlossMassMatrix "mass matrix" and right hand side of the projection.
    * @param[out] boundary_values The result of this function. It is a map
    * containing all indices of degrees of freedom at the boundary (as covered
    * by the boundary parts in @p boundary_functions) and the computed dof
index a20656f70276c978ede8f88691ed610dad3a0fe1..624684e0db4c5f3dcb379b45b71a144d64d54c14 100644 (file)
@@ -66,7 +66,7 @@ namespace VectorTools
    *   (\varphi_i, f_h)_\Omega = (\varphi_i,f)_\Omega
    * @f}
    * for all test functions $\varphi_i$. This requires solving a linear system
-   * involving the mass matrix since the equation above is equivalent to
+   * involving the @ref GlossMassMatrix "mass matrix" since the equation above is equivalent to
    * the linear system
    * @f{align*}{
    *   \sum_j (\varphi_i, \varphi_j)_\Omega F_j = (\varphi_i,f)_\Omega
@@ -102,7 +102,7 @@ namespace VectorTools
    * therefore make sure that the given quadrature formula is sufficiently
    * accurate for creating the right-hand side.
    *
-   * Otherwise, only serial Triangulations are supported and the mass matrix
+   * Otherwise, only serial Triangulations are supported and the @ref GlossMassMatrix "mass matrix"
    * is assembled using MatrixTools::create_mass_matrix. The given
    * quadrature rule is then used for both the matrix and the right-hand side.
    * You should therefore make sure that the given quadrature formula is also
index dd1cfa0ca05d8fd590b7c5100af969f2fd561dcf..09267753192f424ac50890aa6483c8708e775b77 100644 (file)
@@ -234,7 +234,7 @@ namespace SUNDIALS
    *  - implicit_function()
    *  - explicit_function()
    *
-   * If the mass matrix is different from the identity, the user should supply
+   * If the @ref GlossMassMatrix "mass matrix" is different from the identity, the user should supply
    *  - mass_times_vector() and, optionally,
    *  - mass_times_setup()
    *
@@ -611,7 +611,7 @@ namespace SUNDIALS
 
     /**
      * A function object that users may supply and that is intended to compute
-     * the product of the mass matrix with a given vector `v`. This function
+     * the product of the @ref GlossMassMatrix "mass matrix" with a given vector `v`. This function
      * will be called by ARKode (possibly several times) after
      * mass_times_setup() has been called at least once. ARKode tries to do its
      * best to call mass_times_setup() the minimum amount of times.
@@ -631,7 +631,7 @@ namespace SUNDIALS
 
     /**
      * A function object that users may supply and that is intended to set up
-     * the mass matrix. This function is called by ARKode any time a mass
+     * the @ref GlossMassMatrix "mass matrix". This function is called by ARKode any time a mass
      * matrix update is required. The user should compute the mass matrix (or
      * update all the variables that allow the application of the mass matrix).
      * This function is guaranteed to be called by ARKode at least once, before
@@ -738,7 +738,7 @@ namespace SUNDIALS
     /**
      * A LinearSolveFunction object that users may supply and that is intended
      * to solve the linearized system $Ax=b$, where $A = M-\gamma J$ is the
-     * Jacobian of the nonlinear residual. The application of the mass matrix
+     * Jacobian of the nonlinear residual. The application of the @ref GlossMassMatrix "mass matrix"
      * $M$ and Jacobian $J$ are known through the functions mass_times_vector()
      * and jacobian_times_vector() and $\gamma$ is a factor provided by
      * SUNDIALS. The matrix-vector product $Ax$ is encoded in the supplied
@@ -871,7 +871,7 @@ namespace SUNDIALS
      *
      * This function should compute the solution to the preconditioner equation
      * $Pz=r$ and store it in @p z. In this equation $P$ should approximate the
-     * mass matrix $M$.
+     * @ref GlossMassMatrix "mass matrix" $M$.
      *
      * @param[in] t  The current time
      * @param[in] r  The right-hand side of the preconditioner equation
@@ -900,7 +900,7 @@ namespace SUNDIALS
      * specified in mass_preconditioner_solve().
      *
      * This function should prepare the solution of the preconditioner equation
-     * $Pz=r$. In this equation $P$ should approximate the mass matrix $M$.
+     * $Pz=r$. In this equation $P$ should approximate the @ref GlossMassMatrix "mass matrix" $M$.
      *
      * If the mass_preconditioner_setup() function is not provided, then
      * mass_preconditioner_solve() should do all the work by itself.
@@ -1021,7 +1021,7 @@ namespace SUNDIALS
     setup_system_solver(const VectorType &solution);
 
     /**
-     * Set up the solver and preconditioner for a non-identity mass matrix in
+     * Set up the solver and preconditioner for a non-identity @ref GlossMassMatrix "mass matrix" in
      * the ARKODE memory object based on the user-specified functions.
      * @param solution The solution vector which is used as a template to create
      *   new vectors.

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.