// cell - a reference to the right FEValues object (constructed
// with the correct mapping object, finite element, and quadrature rule),
// which can be used as usual to compute the cell integrals.
-// - The cell-local stiffness matrix and the right-hand-side vector have
+// - The cell-local @ref GlossStiffnessMatrix "stiffness matrix" and the right-hand-side vector have
// different sizes depending on the cell type (6 DoFs vs. 9 DoFs) so that
// they might need to be resized for each cell.
//
important to have the numbering of degrees of freedom in mind when
using preconditioners like incomplete LU decompositions. This is most
conveniently visualized using the distribution of nonzero elements in
-the stiffness matrix.
+the @ref GlossStiffnessMatrix "stiffness matrix".
If we don't do anything special to renumber degrees of freedom (i.e.,
without using DoFRenumbering::Cuthill_McKee, but with using
\theta F^n
\right],
@f}
-where $M$ is the @ref GlossMassMatrix "mass matrix" and $A$ is the stiffness matrix that results from
+where $M$ is the @ref GlossMassMatrix "mass matrix" and $A$ is the @ref GlossStiffnessMatrix "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*}
symmetric positive definite and a symmetric positive semidefinite matrix, the
result is also symmetric positive definite. Furthermore, $\frac\beta\alpha$ is
a number proportional to the time step, and so becomes small whenever the mesh
-is fine, damping the effect of the then ill-conditioned stiffness matrix.
+is fine, damping the effect of the then ill-conditioned @ref GlossStiffnessMatrix "stiffness matrix".
As a consequence, inverting this matrix with the Conjugate Gradient algorithm,
using a simple preconditioner, is trivial and very cheap compared to inverting
}
// The creation of the temperature matrix (or, rather, matrices, since we
- // provide a temperature mass matrix and a temperature stiffness matrix,
+ // provide a temperature mass matrix and a temperature @ref GlossStiffnessMatrix "stiffness matrix",
// that will be added together for time discretization) follows the
// generation of the Stokes matrix – except that it is much easier
// here since we do not need to take care of any blocks or coupling
// having inhomogeneous boundary conditions, by just making a right hand
// side at this point (compare the comments for the <code>project()</code>
// function above): We create some matrix columns with exactly the values
- // that would be entered for the temperature stiffness matrix, in case we
+ // that would be entered for the temperature @ref GlossStiffnessMatrix "stiffness matrix", in case we
// have inhomogeneously constrained dofs. That will account for the correct
// balance of the right hand side vector with the matrix system of
// temperature.
\varepsilon_h \sum_j (\phi_i, \phi_j) \tilde{\psi}_j\quad. @f] In
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
+the @ref GlossStiffnessMatrix "stiffness matrix" arising from the differential operator $L$, and
$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$.
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 @ref GlossMassMatrix "mass matrix" for
+ // @ref GlossStiffnessMatrix "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:
}
}
- // Now we build the local cell stiffness matrix and RHS vector. Since the
+ // Now we build the local cell @ref GlossStiffnessMatrix "stiffness matrix" and RHS vector. Since the
// global and local system matrices are symmetric, we can exploit this
// property by building only the lower half of the local matrix and copying
// the values to the upper half. So we only assemble half of the
G_{\alpha} &\dealcoloneq& (g, q_\alpha)_\Gamma \qquad \alpha = 1,\dots, m.
@f}
-While the matrix $K$ is the standard stiffness matrix for the Poisson problem on
+While the matrix $K$ is the standard @ref GlossStiffnessMatrix "stiffness matrix" for the Poisson problem on
$\Omega$, and the vector $G$ is a standard right-hand-side vector for a finite
element problem with forcing term $g$ on $\Gamma$, (see, for example, step-3),
the matrix $C$ or its transpose $C^T$ are non-standard since they couple
directions, i.e. $0\le k,l < d$, and that indices $i,j$ run over degrees
of freedom.
-The local stiffness matrix on cell $K$ therefore has the following entries:
+The local @ref GlossStiffnessMatrix "stiffness matrix" on cell $K$ therefore has the following entries:
@f[
A^K_{ij}
=
mu.value_list(fe_values.get_quadrature_points(), mu_values);
right_hand_side(fe_values.get_quadrature_points(), rhs_values);
- // Then assemble the entries of the local stiffness matrix and right
+ // Then assemble the entries of the local @ref GlossStiffnessMatrix "stiffness matrix" and right
// hand side vector. This follows almost one-to-one the pattern
// described in the introduction of this example. One of the few
// comments in place is that we can compute the number
a cut between a cell, $T \in \mathcal{T}_h$, and $\Omega$ can become arbitrarily small:
$|\Omega \cap T | \rightarrow 0$.
For Neumann boundary conditions,
-the consequence is that the stiffness matrix can become arbitrarily ill-conditioned
+the consequence is that the @ref GlossStiffnessMatrix "stiffness matrix" can become arbitrarily ill-conditioned
as the cut-size approaches zero.
For a Dirichlet condition, the situation is even worse.
For any finite choice of Nitsche constant, $\gamma_D$,
*
* The degrees of freedom are the values at the vertices and the derivatives
* at the midpoint. Currently, we do not scale the polynomials in any way,
- * although better conditioning of the element stiffness matrix could
+ * although better conditioning of the element @ref GlossStiffnessMatrix "stiffness matrix" could
* possibly be achieved with scaling.
*
* Calling the constructor with a given index <tt>p</tt> will generate the
* the documentation of the FiniteElement class, or the one of Triangulation.
*
* Due to the fact that the enrichments are small almost everywhere for large
- * $p$, the condition number for the mass and stiffness matrix quickly
+ * $p$, the condition number for the mass and @ref GlossStiffnessMatrix "stiffness matrix" quickly
* increaseses with increasing $p$. Below you see a comparison with
* FE_Q(QGaussLobatto(p+1)) for dim=1.
*
* defined by the finite element passed to `fe_values`, and `j` taking
* on a specified subset of `i`'s range, starting at `i` itself and ending at
* the number of cell degrees of freedom. In this way, we can construct the
- * upper half and the diagonal of a stiffness matrix contribution (assuming it
+ * upper half and the diagonal of a @ref GlossStiffnessMatrix "stiffness matrix" contribution (assuming it
* is symmetric, and that only one half of it needs to be computed), for
* example.
*
* defined by the finite element passed to `fe_values`, and `j` taking
* on a specified subset of `i`'s range, starting at zero and ending at
* `i` itself. In this way, we can construct the lower half and the
- * diagonal of a stiffness matrix contribution (assuming it is symmetric, and
+ * diagonal of a @ref GlossStiffnessMatrix "stiffness matrix" contribution (assuming it is symmetric, and
* that only one half of it needs to be computed), for example.
*
* @note If the @p end_dof_index is equal to zero, then the returned index
* situation could be where one wants to assemble of a right hand side
* vector on a problem with inhomogeneous constraints, but the global matrix
* has been assembled previously. A typical example of this is a time
- * stepping algorithm where the stiffness matrix is assembled once, and the
+ * stepping algorithm where the @ref GlossStiffnessMatrix "stiffness matrix" is assembled once, and the
* right hand side updated every time step. Note that, however, the entries
* in the columns of the local matrix have to be exactly the same as those
* that have been written into the global matrix. Otherwise, this function
* A class similar to TensorProductMatrixSymmetricSum.
*
* The class TensorProductMatrixSymmetricSum stores a
- * 1d @ref GlossMassMatrix "mass matrix", 1d stiffness matrix, eigenvalues and eigenvectors
+ * 1d @ref GlossMassMatrix "mass matrix", 1d @ref GlossStiffnessMatrix "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
*
* This observation also translates to the case when different differential
* operators are implemented in a program, for example the action of a mass
- * matrix for one phase of the algorithm and the action of a stiffness matrix
+ * matrix for one phase of the algorithm and the action of a @ref GlossStiffnessMatrix "stiffness matrix"
* in another one. Only a single MatrixFree object is necessary, maintaining
* full efficiency by using different local functions with the respective
* implementation in separate FEEvaluation objects. In other words, a user
* object is the result of an operation is determined by the Assembler using
* them. It is also the assembler that determines <i>how many</i> of each
* kind of object are produced (for example, an assembler may create
- * both the local contributions to a mass and a stiffness matrix), and for
+ * both the local contributions to a mass and a @ref GlossStiffnessMatrix "stiffness matrix"), and for
* setting the arrays of local results to the sizes needed.
*
* The interface of this class allows accessing all of this information
projects / dealii.git / commitdiff