It is often convenient to treat a matrix or vector as a collection of individual blocks. For example, in step20 (and other tutorial programs), we want to consider the global linear system in the form
 + \end{eqnarray*}" src="form_92.png"/>
where are the values of velocity and pressure degrees of freedom, respectively, is the mass matrix on the velocity space, corresponds to the negative divergence operator, and is its transpose and corresponds to the negative gradient.
+where are the values of velocity and pressure degrees of freedom, respectively, is the mass matrix on the velocity space, corresponds to the negative divergence operator, and is its transpose and corresponds to the negative gradient.
Using such a decomposition into blocks, one can then define preconditioners that are based on the individual operators that are present in a system of equations (for example the Schur complement, in the case of step20), rather than the entire matrix. In essence, blocks are used to reflect the structure of a PDE system in linear algebra, in particular allowing for modular solvers for problems with multiple solution components. On the other hand, the matrix and right hand side vector can also treated as a unit, which is convenient for example during assembly of the linear system when one may not want to make a distinction between the individual components, or for an outer Krylov space solver that doesn't care about the block structure (e.g. if only the preconditioner needs the block structure).
Splitting matrices and vectors into blocks is supported by the BlockSparseMatrix, BlockVector, and related classes. See the overview of the various linear algebra classes in the Linear algebra classes module. The objects present two interfaces: one that makes the object look like a matrix or vector with global indexing operations, and one that makes the object look like a collection of subblocks that can be individually addressed. Depending on context, one may wish to use one or the other interface.
Typically, one defines the substructure of a matrix or vector by grouping the degrees of freedom that make up groups of physical quantities (for example all velocities) into individual blocks of the linear system. This is defined in more detail below in the glossary entry on Block (finite element).
@@ 135,7 +135,7 @@With the exception of the number of blocks, the two objects are the same for all practical purposes, however.
Global degrees of freedom: While we have defined blocks above in terms of the vector components of a vectorvalued solution function (or, equivalently, in terms of the vectorvalued finite element space), every shape function of a finite element is part of one block or another. Consequently, we can partition all degrees of freedom defined on a DoFHandler into individual blocks. Since by default the DoFHandler class enumerates degrees of freedom in a more or less random way, you will first want to call the DoFRenumbering::component_wise function to make sure that all degrees of freedom that correspond to a single block are enumerated consecutively.
If you do this, you naturally partition matrices and vectors into blocks as well (see block (linear algebra)). In most cases, when you subdivide a matrix or vector into blocks, you do so by creating one block for each block defined by the finite element (i.e. in most practical cases the FESystem object). However, this needs not be so: the DoFRenumbering::component_wise function allows to group several vector components or finite element blocks into the same logical block (see, for example, the step22 or step31 tutorial programs, as opposed to step20). As a consequence, using this feature, we can achieve the same result, i.e. subdividing matrices into blocks and vectors into 2 blocks, for the second way of creating a Stokes element outlined above using an extra argument as we would have using the first way of creating the Stokes element with two blocks right away.
+If you do this, you naturally partition matrices and vectors into blocks as well (see block (linear algebra)). In most cases, when you subdivide a matrix or vector into blocks, you do so by creating one block for each block defined by the finite element (i.e. in most practical cases the FESystem object). However, this needs not be so: the DoFRenumbering::component_wise function allows to group several vector components or finite element blocks into the same logical block (see, for example, the step22 or step31 tutorial programs, as opposed to step20). As a consequence, using this feature, we can achieve the same result, i.e. subdividing matrices into blocks and vectors into 2 blocks, for the second way of creating a Stokes element outlined above using an extra argument as we would have using the first way of creating the Stokes element with two blocks right away.
More information on this topic can be found in the documentation of FESystem, the Handling vector valued problems module and the tutorial programs referenced therein.
Selecting blocks: Many functions allow you to restrict their operation to certain vector components or blocks. For example, this is the case for the functions that interpolate boundary values: one may want to only interpolate the boundary values for the velocity block of a finite element field but not the pressure block. The way to do this is by passing a BlockMask argument to such functions, see the block mask entry of this glossary.
@@ 164,14 +164,14 @@For a dimdimensional triangulation in dimdimensional space, the boundary form is a vector defined on faces. It is the vector product of the image of coordinate vectors on the surface of the unit cell. It is a vector normal to the surface, pointing outwards and having the length of the surface element.
A more general definition would be that (at least up to the length of this vector) it is exactly that vector that is necessary when considering integration by parts, i.e. equalities of the form . Using this definition then also explains what this vector should be in the case of domains (and corresponding triangulations) of dimension dim
that are embedded in a space spacedim
: in that case, the boundary form is still a vector defined on the faces of the triangulation; it is orthogonal to all tangent directions of the boundary and within the tangent plane of the domain. Note that this is compatible with case dim==spacedim
since there the tangent plane is the entire space .
A more general definition would be that (at least up to the length of this vector) it is exactly that vector that is necessary when considering integration by parts, i.e. equalities of the form . Using this definition then also explains what this vector should be in the case of domains (and corresponding triangulations) of dimension dim
that are embedded in a space spacedim
: in that case, the boundary form is still a vector defined on the faces of the triangulation; it is orthogonal to all tangent directions of the boundary and within the tangent plane of the domain. Note that this is compatible with case dim==spacedim
since there the tangent plane is the entire space .
In either case, the length of the vector equals the determinant of the transformation of reference face to the face of the current cell.
In a Triangulation object, every part of the boundary may be associated with a unique number (of type types::boundary_id) that is used to determine what kinds of boundary conditions are to be applied to a particular part of a boundary. The boundary is composed of the faces of the cells and, in 3d, the edges of these faces.
By default, all boundary indicators of a mesh are zero, unless you are reading from a mesh file that specifically sets them to something different, or unless you use one of the mesh generation functions in namespace GridGenerator that have a colorize option. A typical piece of code that sets the boundary indicator on part of the boundary to something else would look like this, here setting the boundary indicator to 42 for all faces located at :
By default, all boundary indicators of a mesh are zero, unless you are reading from a mesh file that specifically sets them to something different, or unless you use one of the mesh generation functions in namespace GridGenerator that have a colorize option. A typical piece of code that sets the boundary indicator on part of the boundary to something else would look like this, here setting the boundary indicator to 42 for all faces located at :
When considering systems of equations in which the solution is not just a single scalar function, we say that we have a vector system with a vectorvalued solution. For example, the vector solution in the elasticity equation considered in step8 is consisting of the displacements in each of the three coordinate directions. The solution then has three elements. Similarly, the 3d Stokes equation considered in step22 has four elements: . We call the elements of the vectorvalued solution components in deal.II. To be wellposed, for the solution to have components, there need to be partial differential equations to describe them. This concept is discussed in great detail in the Handling vector valued problems module.
+When considering systems of equations in which the solution is not just a single scalar function, we say that we have a vector system with a vectorvalued solution. For example, the vector solution in the elasticity equation considered in step8 is consisting of the displacements in each of the three coordinate directions. The solution then has three elements. Similarly, the 3d Stokes equation considered in step22 has four elements: . We call the elements of the vectorvalued solution components in deal.II. To be wellposed, for the solution to have components, there need to be partial differential equations to describe them. This concept is discussed in great detail in the Handling vector valued problems module.
In finite element programs, one frequently wants to address individual elements (components) of this vectorvalued solution, or sets of components. For example, we do this extensively in step8, and a lot of documentation is also provided in the module on Handling vector valued problems. If you are thinking only in terms of the partial differential equation (not in terms of its discretization), then the concept of components is the natural one.
On the other hand, when talking about finite elements and degrees of freedom, components are not always the correct concept because components are not always individually addressable. In particular, this is the case for nonprimitive finite elements. Similarly, one may not always want to address individual components but rather sets of components — e.g. all velocity components together, and separate from the pressure in the Stokes system, without further splitting the velocities into their individual components. In either case, the correct concept to think in is that of a block. Since each component, if individually addressable, is also a block, thinking in terms of blocks is most frequently the better strategy.
For a given finite element, the number of components can be queried using the FiniteElementData::n_components() function, and you can find out which vector components are nonzero for a given finite element shape function using FiniteElement::get_nonzero_components(). The values and gradients of individual components of a shape function (if the element is primitive) can be queried using the FiniteElement::shape_value_component() and FiniteElement::shape_grad_component() functions on the reference cell. The FEValues::shape_value_component() and FEValues::shape_grad_component() functions do the same on a real cell. See also the documentation of the FiniteElement and FEValues classes.
@@ 262,7 +262,7 @@ would result in a mask [true, true, false]
in 2d. Of course, in 3d, the result would be [true, true, true, false]
.
[true, false]
because you try to select individual vector components of a finite element where each shape function has both and velocities. In essence, while you can of course create such a component mask, there is nothing you can do with it. [true, false]
because you try to select individual vector components of a finite element where each shape function has both and velocities. In essence, while you can of course create such a component mask, there is nothing you can do with it. For parallel computations, deal.II uses the vector and matrix classes defined in the PETScWrappers and TrilinosWrappers namespaces. When running programs in parallel using MPI, these classes only store a certain number of rows or elements on the current processor, whereas the rest of the vector or matrix is stored on the other processors that belong to our MPI universe. This presents a certain problem when you assemble linear systems: we add elements to the matrix and right hand side vectors that may or may not be stored locally. Sometimes, we may also want to just set an element, not add to it.
@@ 304,9 +304,9 @@The term "degree of freedom" (often abbreviated as "DoF") is commonly used in the finite element community to indicate two slightly different, but related things. The first is that we'd like to represent the finite element solution as a linear combination of shape functions, in the form . Here, is a vector of expansion coefficients. Because we don't know their values yet (we will compute them as the solution of a linear or nonlinear system), they are called "unknowns" or "degrees of freedom". The second meaning of the term can be explained as follows: A mathematical description of finite element problem is often to say that we are looking for a finite dimensional function that satisfies some set of equations (e.g. for all test functions ). In other words, all we say here that the solution needs to lie in some space . However, to actually solve this problem on a computer we need to choose a basis of this space; this is the set of shape functions we have used above in the expansion of with coefficients . There are of course many bases of the space , but we will specifically choose the one that is described by the finite element functions that are traditionally defined locally on the cells of the mesh. Describing "degrees of freedom" in this context requires us to simply enumerate the basis functions of the space . For elements this means simply enumerating the vertices of the mesh in some way, but for higher elements one also has to enumerate the shape functions that are associated with edges, faces, or cell interiors of the mesh. The class that provides this enumeration of the basis functions of is called DoFHandler. The process of enumerating degrees of freedom is referred to as "distributing DoFs" in deal.II.
+The term "degree of freedom" (often abbreviated as "DoF") is commonly used in the finite element community to indicate two slightly different, but related things. The first is that we'd like to represent the finite element solution as a linear combination of shape functions, in the form . Here, is a vector of expansion coefficients. Because we don't know their values yet (we will compute them as the solution of a linear or nonlinear system), they are called "unknowns" or "degrees of freedom". The second meaning of the term can be explained as follows: A mathematical description of finite element problem is often to say that we are looking for a finite dimensional function that satisfies some set of equations (e.g. for all test functions ). In other words, all we say here that the solution needs to lie in some space . However, to actually solve this problem on a computer we need to choose a basis of this space; this is the set of shape functions we have used above in the expansion of with coefficients . There are of course many bases of the space , but we will specifically choose the one that is described by the finite element functions that are traditionally defined locally on the cells of the mesh. Describing "degrees of freedom" in this context requires us to simply enumerate the basis functions of the space . For elements this means simply enumerating the vertices of the mesh in some way, but for higher elements one also has to enumerate the shape functions that are associated with edges, faces, or cell interiors of the mesh. The class that provides this enumeration of the basis functions of is called DoFHandler. The process of enumerating degrees of freedom is referred to as "distributing DoFs" in deal.II.
A distorted cell is a cell for which the mapping from the reference cell to real cell has a Jacobian whose determinant is nonpositive somewhere in the cell. Typically, we only check the sign of this determinant at the vertices of the cell. The function GeometryInfo::alternating_form_at_vertices computes these determinants at the vertices.
By way of example, if all of the determinants are of roughly equal value and on the order of then the cell is wellshaped. For example, a square cell or face has determinants equal to whereas a strongly sheared parallelogram has a determinant much smaller. Similarly, a cell with very unequal edge lengths will have widely varying determinants. Conversely, a pinched cell in which the location of two or more vertices is collapsed to a single point has a zero determinant at this location. Finally, an inverted or twisted cell in which the location of two vertices is out of order will have negative determinants.
+By way of example, if all of the determinants are of roughly equal value and on the order of then the cell is wellshaped. For example, a square cell or face has determinants equal to whereas a strongly sheared parallelogram has a determinant much smaller. Similarly, a cell with very unequal edge lengths will have widely varying determinants. Conversely, a pinched cell in which the location of two or more vertices is collapsed to a single point has a zero determinant at this location. Finally, an inverted or twisted cell in which the location of two vertices is out of order will have negative determinants.
The following two images show a wellformed, a pinched, and a twisted cell for both 2d and 3d:
"Generalized support points" are, as the name suggests, a generalization of support points. The latter are used to describe that a finite element simply interpolates values at individual points (the "support points"). If we call these points (where the hat indicates that these points are defined on the reference cell ), then one typically defines shape functions in such a way that the nodal functionals simply evaluate the function at the support point, i.e., that , and the basis is chosen so that where is the Kronecker delta function. This leads to the common Lagrange elements.
(In the vector valued case, the only other piece of information besides the support points that one needs to provide is the vector component the th node functional corresponds, so that .)
On the other hand, there are other kinds of elements that are not defined this way. For example, for the lowest order RaviartThomas element (see the FE_RaviartThomas class), the node functional evaluates not individual components of a vectorvalued finite element function with dim
components, but the normal component of this vector:
(In the vector valued case, the only other piece of information besides the support points
On the other hand, there are other kinds of elements that are not defined this way. For example, for the lowest order RaviartThomas element (see the FE_RaviartThomas class), the node functional evaluates not individual components of a vectorvalued finite element function with dim
components, but the normal component of this vector:
In these cases, the element does not have support points because it is not purely interpolatory; however, some kind of interpolation is still involved when defining shape functions as the node functionals still require point evaluations at special points
Finally, there are elements that still do not fit into this scheme. For example, some hierarchical basis functions (see, for example the FE_Q_Hierarchical element) are defined so that the node functionals are moments of finite element functions,
In these cases, the element does not have support points because it is not purely interpolatory; however, some kind of interpolation is still involved when defining shape functions as the node functionals still require point evaluations at special points
Finally, there are elements that still do not fit into this scheme. For example, some hierarchical basis functions (see, for example the FE_Q_Hierarchical element) are defined so that the node functionals are moments of finite element functions,
The mass matrix is a matrix of the form

It frequently appears in the solution of time dependent problems where, if one uses an explicit time stepping method, it then leads to the need to solve problems of the form

in time step
The presence of the matrix
Historically, mass lumping was performed by adding the elements of a row together and setting the diagonal entries of

The presence of the matrix
Historically, mass lumping was performed by adding the elements of a row together and setting the diagonal entries of
+
by quadrature

where we choose the quadrature points as the nodes at which the shape functions are defined. If we order the quadrature points in the same way as the shape functions, then

and consequently

where the sum extends over those cells on which
Whether or not this particular choice of quadrature formula is sufficient to retain the convergence rate of the discretization is a separate question. For the usual
where the sum extends over those cells on which
Whether or not this particular choice of quadrature formula is sufficient to retain the convergence rate of the discretization is a separate question. For the usual
For an example of where lumped mass matrices play a role, see step69.
Every object that makes up a Triangulation (cells, faces, edges, etc.), is associated with a unique number (of type types::manifold_id) that is used to identify which manifold object is responsible to generate new points when the mesh is refined.
By default, all manifold indicators of a mesh are set to numbers::flat_manifold_id. A typical piece of code that sets the manifold indicator on a object to something else would look like this, here setting the manifold indicator to 42 for all cells whose center has an
By default, all manifold indicators of a mesh are set to numbers::flat_manifold_id. A typical piece of code that sets the manifold indicator on a object to something else would look like this, here setting the manifold indicator to 42 for all cells whose center has an
The "mass matrix" is a matrix of the form

possibly with a coefficient inside the integral, and where

+
Solving the fourthorder biharmonic equation using the
+step47
Solving the fourthorder biharmonic equation using the
Keywords: FEInterfaceValues
Improved: The FEValuesViews objects that one gets when writing things like fe_values[velocities]
(see Handling vector valued problems) have become a lot smarter. They now compute a significant amount of data at creation time, rather than on the fly. This means that creating such objects becomes more expensive but using them is cheaper. To offset this cost, FEValuesBase objects now create all possible FEValuesViews objects at creation time, rather than whenever you do things like fe_values[velocities]
, and simply return a reference to a pregenerated object. This turns an
+
Improved: The FEValuesViews objects that one gets when writing things like fe_values[velocities]
(see Handling vector valued problems) have become a lot smarter. They now compute a significant amount of data at creation time, rather than on the fly. This means that creating such objects becomes more expensive but using them is cheaper. To offset this cost, FEValuesBase objects now create all possible FEValuesViews objects at creation time, rather than whenever you do things like fe_values[velocities]
, and simply return a reference to a pregenerated object. This turns an
(WB 2008/12/10)
New: There are new functions FullMatrix::cholesky and FullMatrix::outer_product. FullMatrix::cholesky finds the Cholesky decomposition of a matrix in lower triangular form. FullMatrix::outer_product calculates *this
+
New: There are new functions FullMatrix::cholesky and FullMatrix::outer_product. FullMatrix::cholesky finds the Cholesky decomposition of a matrix in lower triangular form. FullMatrix::outer_product calculates *this
(Jean Marie Linhart 2009/07/27)
New: There is now a new class Functions::InterpolatedTensorProductGridData that can be used to (bi/tri)linearly interpolate data given on a tensor product mesh of
+
New: There is now a new class Functions::InterpolatedTensorProductGridData that can be used to (bi/tri)linearly interpolate data given on a tensor product mesh of
(Wolfgang Bangerth, 2013/12/20)
Fixed: The FE_ABF class reported the maximal polynomial degree (via FiniteElement::degree) for elements of order
+
Fixed: The FE_ABF class reported the maximal polynomial degree (via FiniteElement::degree) for elements of order
(Wolfgang Bangerth, 2017/01/13)
Improved: GridGenerator::hyper_shell() in 3d now supports more n_cells
options. While previously only 6, 12, or 96 cells were possible, the function now supports any number of the kind
+
Improved: GridGenerator::hyper_shell() in 3d now supports more n_cells
options. While previously only 6, 12, or 96 cells were possible, the function now supports any number of the kind
(Martin Kronbichler, 2020/04/07)
Improved: The additional roots of the HermiteLikeInterpolation with degree
+
Improved: The additional roots of the HermiteLikeInterpolation with degree
(Martin Kronbichler, 2019/07/12)
The algorithms used in the implementation of this class are described in some detail in the hppaper. There is also a significant amount of documentation on how to use this class in the Constraints on degrees of freedom module.
Each "line" in objects of this class corresponds to one constrained degree of freedom, with the number of the line being i, entered by using add_line() or add_lines(). The entries in this line are pairs of the form (j,a_{ij}), which are added by add_entry() or add_entries(). The organization is essentially a SparsityPattern, but with only a few lines containing nonzero elements, and therefore no data wasted on the others. For each line, which has been added by the mechanism above, an elimination of the constrained degree of freedom of the form

is performed, where b_{i} is optional and set by set_inhomogeneity(). Thus, if a constraint is formulated for instance as a zero mean value of several degrees of freedom, one of the degrees has to be chosen to be eliminated.
Note that the constraints are linear in the x_{i}, and that there might be a constant (nonhomogeneous) term in the constraint. This is exactly the form we need for hanging node constraints, where we need to constrain one degree of freedom in terms of others. There are other conditions of this form possible, for example for implementing mean value conditions as is done in the step11 tutorial program. The name of the class stems from the fact that these constraints can be represented in matrix form as X x = b, and this object then describes the matrix X and the vector b. The most frequent way to create/fill objects of this type is using the DoFTools::make_hanging_node_constraints() function. The use of these objects is first explained in step6.
@@ 914,13 +914,13 @@Add an entry to a given line. In other words, this function adds a term
Add an entry to a given line. In other words, this function adds a term
If an entry with the same indices as the one this function call denotes already exists, then this function simply returns provided that the value of the entry is the same. Thus, it does no harm to enter a constraint twice.
[in]  constrained_dof_index  The index 
[in]  column  The index 
[in]  weight  The factor 
[in]  constrained_dof_index  The index 
[in]  column  The index 
[in]  weight  The factor 
Set an inhomogeneity to the constraint for a degree of freedom. In other words, it adds a constant
Set an inhomogeneity to the constraint for a degree of freedom. In other words, it adds a constant
[in]  constrained_dof_index  The index 
[in]  value  The right hand side value 
[in]  constrained_dof_index  The index 
[in]  value  The right hand side value 
Close the filling of entries. Since the lines of a matrix of this type are usually filled in an arbitrary order and since we do not want to use associative constrainers to store the lines, we need to sort the lines and within the lines the columns before usage of the matrix. This is done through this function.
Also, zero entries are discarded, since they are not needed.
After closing, no more entries are accepted. If the object was already closed, then this function returns immediately.
This function also resolves chains of constraints. For example, degree of freedom 13 may be constrained to
This function also resolves chains of constraints. For example, degree of freedom 13 may be constrained to
Print the constraints represented by the current object to the given stream.
For each constraint of the form

this function will write a sequence of lines that look like this:
This function takes a matrix of local contributions (local_matrix
) corresponding to the degrees of freedom indices given in local_dof_indices
and distributes them to the global matrix. In other words, this function implements a scatter operation. In most cases, these local contributions will be the result of an integration over a cell or face of a cell. However, as long as local_matrix
and local_dof_indices
have the same number of elements, this function is happy with whatever it is given.
In contrast to the similar function in the DoFAccessor class, this function also takes care of constraints, i.e. if one of the elements of local_dof_indices
belongs to a constrained node, then rather than writing the corresponding element of local_matrix
into global_matrix
, the element is distributed to the entries in the global matrix to which this particular degree of freedom is constrained.
With this scheme, we never write into rows or columns of constrained degrees of freedom. In order to make sure that the resulting matrix can still be inverted, we need to do something with the diagonal elements corresponding to constrained nodes. Thus, if a degree of freedom in local_dof_indices
is constrained, we distribute the corresponding entries in the matrix, but also add the absolute value of the diagonal entry of the local matrix to the corresponding entry in the global matrix. Assuming the discretized operator is positive definite, this guarantees that the diagonal entry is always nonzero, positive, and of the same order of magnitude as the other entries of the matrix. On the other hand, when solving a source problem
With this scheme, we never write into rows or columns of constrained degrees of freedom. In order to make sure that the resulting matrix can still be inverted, we need to do something with the diagonal elements corresponding to constrained nodes. Thus, if a degree of freedom in local_dof_indices
is constrained, we distribute the corresponding entries in the matrix, but also add the absolute value of the diagonal entry of the local matrix to the corresponding entry in the global matrix. Assuming the discretized operator is positive definite, this guarantees that the diagonal entry is always nonzero, positive, and of the same order of magnitude as the other entries of the matrix. On the other hand, when solving a source problem
By using this function to distribute local contributions to the global object, one saves the call to the condense function after the vectors and matrices are fully assembled.
This function does almost the same as the function above but can treat general rectangular matrices. The main difference to achieve this is that the diagonal entries in constrained rows are left untouched instead of being filled with arbitrary values.
Since the diagonal entries corresponding to eliminated degrees of freedom are not set, the result may have a zero eigenvalue, if applied to a square matrix. This has to be considered when solving the resulting problems. For solving a source problem
Since the diagonal entries corresponding to eliminated degrees of freedom are not set, the result may have a zero eigenvalue, if applied to a square matrix. This has to be considered when solving the resulting problems. For solving a source problem
Given a vector, set all constrained degrees of freedom to values so that the constraints are satisfied. For example, if the current object stores the constraint
Given a vector, set all constrained degrees of freedom to values so that the constraints are satisfied. For example, if the current object stores the constraint
vec
, then the vector must not contain ghost elements. For fixed theta, the CrankNicolson scheme is the only second order scheme. Nevertheless, further stability may be achieved by choosing theta larger than Â½, thereby introducing a first order error term. In order to avoid a loss of convergence order, the adaptive theta scheme can be used, where theta=Â½+c dt.
Assume that we want to solve the equation u' + F(u) = 0 with a step size k. A step of the theta scheme can be written as

Here, M is the 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 implementation of the theta scheme will use two Operator objects, one for the explicit, one for the implicit part. Each of these will use its own TimestepData to account for the modified step sizes (and different times if the problem is not autonomous). Note that once the explicit part has been computed, the left hand side actually constitutes a linear or nonlinear system which has to be solved.
Now we need to study the application of the implicit and explicit operator. We assume that the pointer matrix
points to the matrix created in the main program (the constructor did this for us). Here, we first get the time step size from the AnyData object that was provided as input. Then, if we are in the first step or if the timestep has changed, we fill the local matrix

Now we need to study the application of the implicit and explicit operator. We assume that the pointer matrix
points to the matrix created in the main program (the constructor did this for us). Here, we first get the time step size from the AnyData object that was provided as input. Then, if we are in the first step or if the timestep has changed, we fill the local matrix
+
After we have worked off the notifications, we clear them, such that the matrix is only generated when necessary.
The operator computing the explicit part of the scheme. This will receive in its input data the value at the current time with name "Current time solution". It should obtain the current time and time step size from explicit_data().
Its return value is
Its return value is
Definition at line 416 of file theta_timestepping.h.
@@ 1170,7 +1170,7 @@The operator solving the implicit part of the scheme. It will receive in its input data the vector "Previous time". Information on the timestep should be obtained from implicit_data().
Its return value is the solution u of MucF(u)=f, where f is the dual space vector found in the "Previous time" entry of the input data, M the mass matrix, F the operator in space and c is the adjusted time step size
Its return value is the solution u of MucF(u)=f, where f is the dual space vector found in the "Previous time" entry of the input data, M the mass matrix, F the operator in space and c is the adjusted time step size
Definition at line 428 of file theta_timestepping.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classAnisotropicPolynomials.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classAnisotropicPolynomials.html 20240412 04:45:49.163558593 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAnisotropicPolynomials.html 20240412 04:45:49.159558566 +0000 @@ 154,10 +154,10 @@Anisotropic tensor product of given polynomials.
Given onedimensional polynomials dim
is in fact only 2. If dim
is in fact only 1, then the result is simply the same set of onedimensional polynomials passed to the constructor.)
If the elements of each set of base polynomials are mutually orthogonal on the interval
The resulting dimdimensional
tensor product polynomials are ordered as follows: We iterate over the dim==2
, the first few polynomials are thus
Given onedimensional polynomials dim
is in fact only 2. If dim
is in fact only 1, then the result is simply the same set of onedimensional polynomials passed to the constructor.)
If the elements of each set of base polynomials are mutually orthogonal on the interval
The resulting dimdimensional
tensor product polynomials are ordered as follows: We iterate over the dim==2
, the first few polynomials are thus
Definition at line 322 of file tensor_product_polynomials.h.
Each tensor product polynomial i
.
Each tensor product polynomial i
.
Definition at line 538 of file tensor_product_polynomials.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classArpackSolver.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classArpackSolver.html 20240412 04:45:49.199558842 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classArpackSolver.html 20240412 04:45:49.203558871 +0000 @@ 230,14 +230,14 @@Interface for using ARPACK. ARPACK is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. Here we interface to the routines dnaupd
and dneupd
of ARPACK. If the operator is specified to be symmetric we use the symmetric interface dsaupd
and dseupd
of ARPACK instead. The package is designed to compute a few eigenvalues and corresponding eigenvectors of a general n by n matrix A. It is most appropriate for large sparse matrices A.
In this class we make use of the method applied to the generalized eigenspectrum problem
In this class we make use of the method applied to the generalized eigenspectrum problem
The ArpackSolver can be used in application codes with serial objects in the following way:
for the generalized eigenvalue problem size_of_spectrum
tells ARPACK the number of eigenvector/eigenvalue pairs to solve for. Here, lambda
is a vector that will contain the eigenvalues computed, x
a vector that will contain the eigenvectors computed, and OP
is an inverse operation for the matrix A
. Shift and invert transformation around zero is applied.
for the generalized eigenvalue problem size_of_spectrum
tells ARPACK the number of eigenvector/eigenvalue pairs to solve for. Here, lambda
is a vector that will contain the eigenvalues computed, x
a vector that will contain the eigenvectors computed, and OP
is an inverse operation for the matrix A
. Shift and invert transformation around zero is applied.
Through the AdditionalData the user can specify some of the parameters to be set.
For further information on how the ARPACK routines dsaupd
, dseupd
, dnaupd
and dneupd
work and also how to set the parameters appropriately please take a look into the ARPACK manual.
Solve the generalized eigensprectrum problem dsaupd
and dseupd
or dnaupd
and dneupd
functions of ARPACK.
Solve the generalized eigensprectrum problem dsaupd
and dseupd
or dnaupd
and dneupd
functions of ARPACK.
The function returns a vector of eigenvalues of length n and a vector of eigenvectors of length n in the symmetric case and of length n+1 in the nonsymmetric case. In the symmetric case all eigenvectors are real. In the nonsymmetric case complex eigenvalues always occur as complex conjugate pairs. Therefore the eigenvector for an eigenvalue with nonzero complex part is stored by putting the real and the imaginary parts in consecutive realvalued vectors. The eigenvector of the complex conjugate eigenvalue does not need to be stored, since it is just the complex conjugate of the stored eigenvector. Thus, if the last nth eigenvalue has a nonzero imaginary part, Arpack needs in total n+1 realvalued vectors to store real and imaginary parts of the eigenvectors.
Return a reference to the
Return a reference to the
This function is marked as const
because it does not change the view object. It may however return a reference to a nonconst
memory location depending on whether the template type of the class is const
or not.
This function is only allowed to be called if the underlying data is indeed stored in CPU memory.
/usr/share/doc/packages/dealii/doxygen/deal.II/classAutoDerivativeFunction.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classAutoDerivativeFunction.html 20240412 04:45:49.335559785 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAutoDerivativeFunction.html 20240412 04:45:49.335559785 +0000 @@ 353,27 +353,27 @@Names of difference formulas.
where each value
where each value
A base class for thin QR implementations.
This class and classes derived from it are meant to build
As a consequence, matrices which have the same number of rows as each vector (i.e. VectorType
.
This class and classes derived from it are meant to build
As a consequence, matrices which have the same number of rows as each vector (i.e. VectorType
.
Solve x
and y
should be consistent with the current size of the subspace. If transpose
is true
,
Solve x
and y
should be consistent with the current size of the subspace. If transpose
is true
,
Set
Set
Implemented in QR< VectorType >, and ImplicitQR< VectorType >.
@@ 434,7 +434,7 @@Set
Set
Implemented in QR< VectorType >, and ImplicitQR< VectorType >.
@@ 468,7 +468,7 @@Set
Set
Implemented in QR< VectorType >, and ImplicitQR< VectorType >.
@@ 502,7 +502,7 @@Set
Set
Implemented in QR< VectorType >, and ImplicitQR< VectorType >.
@@ 557,7 +557,7 @@Compute
Compute
BlockIndices represents a range of indices (such as the range
BlockIndices represents a range of indices (such as the range
The information that can be obtained from this class falls into two groups. First, it is possible to query the global size of the index space (through the total_size() member function), and the number of blocks and their sizes (via size() and the block_size() functions).
Secondly, this class manages the conversion of global indices to the local indices within this block, and the other way around. This is required, for example, when you address a global element in a block vector and want to know within which block this is, and which index within this block it corresponds to. It is also useful if a matrix is composed of several blocks, where you have to translate global row and column indices to local ones.
and Id_c
is the projection to the subspace consisting of all vector entries associated with constrained degrees of freedom.
This LinearOperator object is used together with constrained_right_hand_side() to build up the following modified system of linear equations:

with a given (unconstrained) system matrix
A detailed explanation of this approach is given in the Constraints on degrees of freedom module.
@@ 830,9 +830,9 @@with
This LinearOperator object is used together with constrained_right_hand_side() to build up the following modified system of linear equations:

with a given (unconstrained) system matrix
A detailed explanation of this approach is given in the Constraints on degrees of freedom module.
@@ 1530,7 +1530,7 @@Return a LinearOperator that performs the operations associated with the Schur complement. There are two additional helper functions, condense_schur_rhs() and postprocess_schur_solution(), that are likely necessary to be used in order to perform any useful tasks in linear algebra with this operator.
We construct the definition of the Schur complement in the following way:
Consider a general system of linear equations that can be decomposed into two major sets of equations:

where
where
This is equivalent to the following two statements:

Assuming that

+
which amount to performing block Gaussian elimination on this system of equations.
For the purpose of the current implementation, we choose to substitute (3) into (2)

This leads to the result

with
So for any arbitrary vector

So for any arbitrary vector
+
A typical set of steps needed the solve a linear system (1),(2) would be:
A_inv
(using inverse_operator()).


+

In the above example, the preconditioner for
A better preconditioner in such a case would be one that provides a more representative approximation for
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for
In the above example, the preconditioner for
A better preconditioner in such a case would be one that provides a more representative approximation for
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for
Note that due to the construction of S_inv_approx
and subsequently S_inv
, there are a pair of nested iterative solvers which could collectively consume a lot of resources. Therefore care should be taken in the choices leading to the construction of the iterative inverse_operators. One might consider the use of a IterationNumberControl (or a similar mechanism) to limit the number of inner solver iterations. This controls the accuracy of the approximate inverse operation
Note that due to the construction of S_inv_approx
and subsequently S_inv
, there are a pair of nested iterative solvers which could collectively consume a lot of resources. Therefore care should be taken in the choices leading to the construction of the iterative inverse_operators. One might consider the use of a IterationNumberControl (or a similar mechanism) to limit the number of inner solver iterations. This controls the accuracy of the approximate inverse operation
However, if an iterative solver based on IterationNumberControl is used as a preconditioner then the preconditioning operation is not a linear operation. Here a flexible solver like SolverFGMRES (flexible GMRES) is best employed as an outer solver in order to deal with the variable behavior of the preconditioner. Otherwise the iterative solver can stagnate somewhere near the tolerance of the preconditioner or generally behave erratically. Alternatively, using a ReductionControl would ensure that the preconditioner always solves to the same tolerance, thereby rendering its behavior constant.
Further examples of this functionality can be found in the testsuite, such as tests/lac/schur_complement_01.cc
. The solution of a multi component problem (namely step22) using the schur_complement can be found in tests/lac/schur_complement_03.cc
.
Return the number of blocks in a column (i.e, the number of "block rows", or the number
Return the number of blocks in a column (i.e, the number of "block rows", or the number
Definition at line 297 of file block_linear_operator.h.
@@ 1711,7 +1711,7 @@Return the number of blocks in a row (i.e, the number of "block columns", or the number
Return the number of blocks in a row (i.e, the number of "block columns", or the number
Definition at line 303 of file block_linear_operator.h.
@@ 1730,7 +1730,7 @@Access the block with the given coordinates. This std::function
object returns a LinearOperator representing the
Access the block with the given coordinates. This std::function
object returns a LinearOperator representing the
Definition at line 310 of file block_linear_operator.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBlockMatrixBase.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockMatrixBase.html 20240412 04:45:49.595561586 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockMatrixBase.html 20240412 04:45:49.603561641 +0000 @@ 1296,7 +1296,7 @@ const BlockVectorType & src&#href_anchor"memdoc"> Adding Matrixvector multiplication. Add
Adding Matrixvector multiplication. Add
Compute the matrix scalar product
Compute the matrix scalar product
Matrixvector multiplication: let
Matrixvector multiplication: let
Due to problems with deriving template arguments between the block and nonblock versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
Matrixvector multiplication: let
Matrixvector multiplication: let
Due to problems with deriving template arguments between the block and nonblock versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 396 of file block_sparse_matrix.h.
@@ 1069,7 +1069,7 @@Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 440 of file block_sparse_matrix.h.
@@ 2061,7 +2061,7 @@Adding Matrixvector multiplication. Add
Adding Matrixvector multiplication. Add
Compute the matrix scalar product
Compute the matrix scalar product
Matrixvector multiplication: let
Matrixvector multiplication: let
Due to problems with deriving template arguments between the block and nonblock versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
Matrixvector multiplication: let
Matrixvector multiplication: let
Due to problems with deriving template arguments between the block and nonblock versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 371 of file block_sparse_matrix_ez.h.
@@ 779,7 +779,7 @@ const BlockVector< somenumber > & src&#href_anchor"memdoc"> Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 409 of file block_sparse_matrix_ez.h.
@@ 804,7 +804,7 @@ const BlockVector< somenumber > & src&#href_anchor"memdoc"> Adding Matrixvector multiplication. Add
Adding Matrixvector multiplication. Add
Definition at line 391 of file block_sparse_matrix_ez.h.
@@ 829,7 +829,7 @@ const BlockVector< somenumber > & src&#href_anchor"memdoc"> Adding Matrixvector multiplication. Add
Adding Matrixvector multiplication. Add
Definition at line 429 of file block_sparse_matrix_ez.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVector.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVector.html 20240412 04:45:49.795562972 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVector.html 20240412 04:45:49.803563027 +0000 @@ 1768,7 +1768,7 @@Return the square of the
Return the square of the
Return the
Return the
Return the
Return the
Return the maximum absolute value of the elements of this vector, which is the
Return the maximum absolute value of the elements of this vector, which is the
Return the square of the
Return the square of the
Return the
Return the
Return the
Return the
Return the maximum absolute value of the elements of this vector, which is the
Return the maximum absolute value of the elements of this vector, which is the
A class that represents a box of arbitrary dimension spacedim
and with sides parallel to the coordinate axes, that is, a region

where
where
Geometrically, a bounding box is thus:
Bounding boxes are, for example, useful in parallel distributed meshes to give a general description of the owners of each portion of the mesh. More generally, bounding boxes are often used to roughly describe a region of space in which an object is contained; if a candidate point is not within the bounding box (a test that is cheap to execute), then it is not necessary to perform an expensive test whether the candidate point is in fact inside the object itself. Bounding boxes are therefore often used as a first, cheap rejection test before more detailed checks. As such, bounding boxes serve many of the same purposes as the convex hull, for which it is also relatively straightforward to compute whether a point is inside or outside, though not quite as cheap as for the bounding box.
Taking the cross section of a BoundingBox<spacedim> orthogonal to a given direction gives a box in one dimension lower: BoundingBox<spacedim  1>. In 3d, the 2 coordinates of the cross section of BoundingBox<3> can be ordered in 2 different ways. That is, if we take the cross section orthogonal to the y direction we could either order a 3dcoordinate into a 2dcoordinate as
Taking the cross section of a BoundingBox<spacedim> orthogonal to a given direction gives a box in one dimension lower: BoundingBox<spacedim  1>. In 3d, the 2 coordinates of the cross section of BoundingBox<3> can be ordered in 2 different ways. That is, if we take the cross section orthogonal to the y direction we could either order a 3dcoordinate into a 2dcoordinate as
Orthogonal to  Cross section coordinates ordered as 

Returns the indexth vertex of the box. Vertex is meant in the same way as for a cell, so that index
Returns the indexth vertex of the box. Vertex is meant in the same way as for a cell, so that index
Definition at line 233 of file bounding_box.cc.
@@ 799,7 +799,7 @@Apply the affine transformation that transforms this BoundingBox to a unit BoundingBox object.
If point
.
If point
.
Definition at line 312 of file bounding_box.cc.
@@ 822,7 +822,7 @@Apply the affine transformation that transforms the unit BoundingBox object to this object.
If point
.
If point
.
Definition at line 327 of file bounding_box.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionIC.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionIC.html 20240412 04:45:49.939563969 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionIC.html 20240412 04:45:49.943563996 +0000 @@ 480,7 +480,7 @@cuSPARSE description of the lower triangular matrix
cuSPARSE description of the lower triangular matrix
Definition at line 176 of file cuda_precondition.h.
@@ 534,7 +534,7 @@Solve and analysis structure for the lower triangular matrix
Solve and analysis structure for the lower triangular matrix
Definition at line 186 of file cuda_precondition.h.
@@ 750,7 +750,7 @@Determine if level information should be generated for the lower triangular matrix
Determine if level information should be generated for the lower triangular matrix
Definition at line 233 of file cuda_precondition.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionILU.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionILU.html 20240412 04:45:49.979564247 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1PreconditionILU.html 20240412 04:45:49.983564274 +0000 @@ 482,7 +482,7 @@cuSPARSE description of the lower triangular matrix
cuSPARSE description of the lower triangular matrix
Definition at line 388 of file cuda_precondition.h.
@@ 563,7 +563,7 @@Solve and analysis structure for the lower triangular matrix
Solve and analysis structure for the lower triangular matrix
Definition at line 403 of file cuda_precondition.h.
@@ 779,7 +779,7 @@Determine if level information should be generated for the lower triangular matrix
Determine if level information should be generated for the lower triangular matrix
Definition at line 450 of file cuda_precondition.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1SparseMatrix.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1SparseMatrix.html 20240412 04:45:50.031564606 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCUDAWrappers_1_1SparseMatrix.html 20240412 04:45:50.035564634 +0000 @@ 775,7 +775,7 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & src&#href_anchor"memdoc"> Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 512 of file cuda_sparse_matrix.cc.
@@ 798,7 +798,7 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & src&#href_anchor"memdoc"> Matrixvector multiplication: let
Matrixvector multiplication: let
Definition at line 530 of file cuda_sparse_matrix.cc.
@@ 821,7 +821,7 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & src&#href_anchor"memdoc"> Adding matrixvector multiplication. Add
Adding matrixvector multiplication. Add
Definition at line 548 of file cuda_sparse_matrix.cc.
@@ 844,7 +844,7 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & src&#href_anchor"memdoc"> Adding matrixvector multiplication. Add
Adding matrixvector multiplication. Add
Definition at line 566 of file cuda_sparse_matrix.cc.
@@ 866,7 +866,7 @@Return the square of the norm of the vector
Return the square of the norm of the vector
Obviously, the matrix needs to be quadratic for this operation.
Definition at line 584 of file cuda_sparse_matrix.cc.
@@ 890,7 +890,7 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & v&#href_anchor"memdoc"> Compute the matrix scalar product
Compute the matrix scalar product
Definition at line 597 of file cuda_sparse_matrix.cc.
@@ 918,8 +918,8 @@ const LinearAlgebra::CUDAWrappers::Vector< Number > & b&#href_anchor"memdoc"> Compute the residual of an equation
Source
Compute the residual of an equation
Source
Definition at line 611 of file cuda_sparse_matrix.cc.
@@ 941,8 +941,8 @@Return the
Return the
Definition at line 626 of file cuda_sparse_matrix.cc.
@@ 964,8 +964,8 @@Return the
Definition at line 645 of file cuda_sparse_matrix.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classCellAccessor.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCellAccessor.html 20240412 04:45:50.155565466 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCellAccessor.html 20240412 04:45:50.151565437 +0000 @@ 4150,7 +4150,7 @@This function computes a fast approximate transformation from the real to the unit cell by inversion of an affine approximation of the
The affine approximation of the unit to real cell mapping is found by a least squares fit of an affine function to the
The affine approximation of the unit to real cell mapping is found by a least squares fit of an affine function to the
For exact transformations to the unit cell, use Mapping::transform_real_to_unit_cell().
Return the barycenter (also called centroid) of the object. The barycenter for an object

+
where the measure of the object is given by

This function assumes that
This class describes mappings that can be expressed in terms of charts. Specifically, this class with its template arguments describes a chart of dimension chartdim, which is part of a Manifold<dim,spacedim> and is used in an object of type Triangulation<dim,spacedim>: It specializes a Manifold of dimension chartdim embedded in a manifold of dimension spacedim, for which you have explicit pull_back() and push_forward() transformations. Its use is explained in great detail in step53.
This is a helper class which is useful when you have an explicit map from an Euclidean space of dimension chartdim to an Euclidean space of dimension spacedim which represents your manifold, i.e., when your manifold

This is a helper class which is useful when you have an explicit map from an Euclidean space of dimension chartdim to an Euclidean space of dimension spacedim which represents your manifold, i.e., when your manifold
+
(the push_forward() function) and that admits the inverse transformation

(the pull_back() function).
The get_new_point() function of the ChartManifold class is implemented by calling the pull_back() method for all surrounding_points
, computing their weighted average in the chartdim Euclidean space, and calling the push_forward() method with the resulting point, i.e.,

Derived classes are required to implement the push_forward() and the pull_back() methods. All other functions (with the exception of the push_forward_gradient() function, see below) that are required by mappings will then be provided by this class.
In order to compute vectors that are tangent to the manifold (for example, tangent to a surface embedded in higher dimensional space, or simply the three unit vectors of spacedim
times chartdim
.
In order to compute vectors that are tangent to the manifold (for example, tangent to a surface embedded in higher dimensional space, or simply the three unit vectors of spacedim
times chartdim
.
Only the ChartManifold::get_tangent_vector() function uses the gradient of the pushforward, but only a subset of all finite element codes actually require the computation of tangent vectors. Consequently, while derived classes need to implement the abstract virtual push_forward() and pull_back() functions of this class, they do not need to implement the virtual push_forward_gradient() function. Rather, that function has a default implementation (and consequently is not abstract, therefore not forcing derived classes to overload it), but the default implementation clearly can not compute anything useful and therefore simply triggers and exception.
The dimension arguments chartdim
, dim
and spacedim
must satisfy the following relationships:
However, there is no a priori relationship between dim
and chartdim
. For example, if you want to describe a mapping for an edge (a 1d object) in a 2d triangulation embedded in 3d space, you could do so by parameterizing it via a line

in which case chartdim
is 1. On the other hand, there is no reason why one can't describe this as a mapping

in such a way that the line chartdim
is 3. This may seem cumbersome but satisfies the requirements of an invertible function chartdim
is 2.
in such a way that the line chartdim
is 3. This may seem cumbersome but satisfies the requirements of an invertible function chartdim
is 2.
Definition at line 902 of file manifold.h.
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
This function is used in the computations required by the get_tangent_vector() function. Since not all users of the Manifold class interface will require calling that function, the current function is implemented but will trigger an exception whenever called. This allows derived classes to avoid implementing the push_forward_gradient function if this functionality is not needed in the user program.
Refer to the general documentation of this class for more information.
@@ 600,24 +600,24 @@Return a vector that, at
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are

For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are
+
In image space, i.e., in the space in which we operate, this leads to the curve

What the current function is supposed to return is

+
This formula may then have to be slightly modified by considering any periodicity that was assumed in the call to the constructor.
Thus, the computation of tangent vectors also requires the implementation of derivatives
Thus, the computation of tangent vectors also requires the implementation of derivatives
x1  The first point that describes the geodesic, and the one at which the "direction" is to be evaluated. 
Symmetrize the matrix by forming the mean value between the existing matrix and its transpose,
Symmetrize the matrix by forming the mean value between the existing matrix and its transpose,
This operation assumes that the underlying sparsity pattern represents a symmetric object. If this is not the case, then the result of this operation will not be a symmetric matrix, since it only explicitly symmetrizes by looping over the lower left triangular part for efficiency reasons; if there are entries in the upper right triangle, then these elements are missed in the symmetrization. Symmetrization of the sparsity pattern can be obtain by ChunkSparsityPattern::symmetrize().
Return the square of the norm of the vector
Return the square of the norm of the vector
Obviously, the matrix needs to be quadratic for this operation, and for the result to actually be a norm it also needs to be either real symmetric or complex hermitian.
The underlying template types of both this matrix and the given vector should either both be real or complexvalued, but not mixed, for this function to make sense.
@@ 1392,7 +1392,7 @@ const Vector< somenumber > & v&#href_anchor"memdoc"> Compute the matrix scalar product
Compute the matrix scalar product
Return the l1norm of the matrix, that is
Return the l1norm of the matrix, that is
Return the linftynorm of the matrix, that is
Return the linftynorm of the matrix, that is
Return the location of entry
Return the location of entry
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of
Definition at line 520 of file chunk_sparsity_pattern.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classCompositionManifold.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCompositionManifold.html 20240412 04:45:50.399567155 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCompositionManifold.html 20240412 04:45:50.403567183 +0000 @@ 594,24 +594,24 @@Return a vector that, at
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are

For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are
+
In image space, i.e., in the space in which we operate, this leads to the curve

What the current function is supposed to return is

+
This formula may then have to be slightly modified by considering any periodicity that was assumed in the call to the constructor.
Thus, the computation of tangent vectors also requires the implementation of derivatives
Thus, the computation of tangent vectors also requires the implementation of derivatives
x1  The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.  
const unsigned int  dim = 2&#href_anchor"memdoc">
Evaluate the convergence rates of the data column As this class has no information on the space dimension upon which the reference column vs. the value column is based upon, it needs to be passed as last argument to this method. The default dimension for the reference column is 2, which is appropriate for the number of cells in 2d. If you work in 3d, set the number to 3. If the reference column is As this class has no information on the space dimension upon which the reference column vs. the value column is based upon, it needs to be passed as last argument to this method. The default dimension for the reference column is 2, which is appropriate for the number of cells in 2d. If you work in 3d, set the number to 3. If the reference column is The new rate column and the data column will be merged to a supercolumn. The tex caption of the supercolumn will be (by default) the same as the one of the data column. This may be changed by using the This method behaves in the following way: If RateMode is reduction_rate, then the computed output is If RateMode is reduction_rate_log2, then the computed output is This is useful, for example, if we use as reference key the number of degrees of freedom or better, the number of cells. Assuming that the error is proportional to If RateMode is reduction_rate, then the computed output is If RateMode is reduction_rate_log2, then the computed output is This is useful, for example, if we use as reference key the number of degrees of freedom or better, the number of cells. Assuming that the error is proportional to
Definition at line 23 of file convergence_table.cc. /usr/share/doc/packages/dealii/doxygen/deal.II/classCylindricalManifold.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classCylindricalManifold.html 20240412 04:45:50.503567876 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCylindricalManifold.html 20240412 04:45:50.511567930 +0000 @@ 413,7 +413,7 @@ 
Compute the cylindrical coordinates
Compute the cylindrical coordinates
Implements ChartManifold< dim, spacedim, chartdim >.
@@ 445,7 +445,7 @@Compute the Cartesian coordinates for a chart point given in cylindrical coordinates
Compute the Cartesian coordinates for a chart point given in cylindrical coordinates
Definition at line 1144 of file manifold_lib.cc.
@@ 475,7 +475,7 @@Compute the derivatives of the mapping from cylindrical coordinates
Compute the derivatives of the mapping from cylindrical coordinates
Definition at line 1164 of file manifold_lib.cc.
@@ 644,7 +644,7 @@Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
This function is used in the computations required by the get_tangent_vector() function. Since not all users of the Manifold class interface will require calling that function, the current function is implemented but will trigger an exception whenever called. This allows derived classes to avoid implementing the push_forward_gradient function if this functionality is not needed in the user program.
Refer to the general documentation of this class for more information.
@@ 678,24 +678,24 @@Return a vector that, at
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are

For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are
+
In image space, i.e., in the space in which we operate, this leads to the curve

What the current function is supposed to return is

+
This formula may then have to be slightly modified by considering any periodicity that was assumed in the call to the constructor.
Thus, the computation of tangent vectors also requires the implementation of derivatives
Thus, the computation of tangent vectors also requires the implementation of derivatives
As a consequence, DataOut is forced to take things apart into their real and imaginary parts, and both are output as separate quantities. This is the case for data that is written directly to a file by DataOut, but it is also the case for data that is first routed through DataPostprocessor objects (or objects of their derived classes): All these objects see is a collection of real values, even if the underlying solution vector was complexvalued.
All of this has two implications:
step58 provides an example of how this class (or, rather, the derived DataPostprocessorScalar class) is used in a complexvalued situation.
/usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorTensor.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorTensor.html 20240412 04:45:50.579568401 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorTensor.html 20240412 04:45:50.587568457 +0000 @@ 255,7 +255,7 @@These pictures show an ellipse representing the gradient tensor at, on average, every tenth mesh point. You may want to read through the documentation of the VisIt visualization program (see https://wci.llnl.gov/simulation/computercodes/visit/) for an interpretation of how exactly tensors are visualizated.
In elasticity, one is often interested not in the gradient of the displacement, but in the "strain", i.e., the symmetrized version of the gradient
In elasticity, one is often interested not in the gradient of the displacement, but in the "strain", i.e., the symmetrized version of the gradient
In the second image, the background color corresponds to the magnitude of the gradient vector and the vector glyphs to the gradient itself. It may be surprising at first to see that from each vertex, multiple vectors originate, going in different directions. But that is because the solution is only continuous: in general, the gradient is discontinuous across edges, and so the multiple vectors originating from each vertex simply represent the differing gradients of the solution at each adjacent cell.
The output above – namely, the gradient
The output above – namely, the gradient
x1  The first point that describes the geodesic, and the one at which the "direction" is to be evaluated. 
Return the norm of the derivative object. Here, for the (symmetric) tensor of second derivatives, we choose the absolute value of the largest eigenvalue, which is the matrix norm associated to the
Return the norm of the derivative object. Here, for the (symmetric) tensor of second derivatives, we choose the absolute value of the largest eigenvalue, which is the matrix norm associated to the
Definition at line 492 of file derivative_approximation.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1ThirdDerivative.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1ThirdDerivative.html 20240412 04:45:50.687569150 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1ThirdDerivative.html 20240412 04:45:50.691569177 +0000 @@ 230,7 +230,7 @@Return the norm of the derivative object. Here, for the (symmetric) tensor of second derivatives, we choose the absolute value of the largest eigenvalue, which is the matrix norm associated to the
Return the norm of the derivative object. Here, for the (symmetric) tensor of second derivatives, we choose the absolute value of the largest eigenvalue, which is the matrix norm associated to the
Definition at line 631 of file derivative_approximation.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeForm.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeForm.html 20240412 04:45:50.723569399 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeForm.html 20240412 04:45:50.731569455 +0000 @@ 164,24 +164,24 @@ DerivativeForm< 1, spacedim, dim, Number >&#href_anchor"memTemplItemRight" valign="bottom">transpose (const DerivativeForm< 1, dim, spacedim, Number > &DF) &#href_anchor"details" id="details">This class represents the (tangential) derivatives of a function

+
i.e., one needs to be able to multiply the matrix
Similarly, the second derivative is a bilinear map from
i.e., one needs to be able to multiply the matrix
Similarly, the second derivative is a bilinear map from
In deal.II we represent these derivatives using objects of type DerivativeForm<1,dim,spacedim,Number>, DerivativeForm<2,dim,spacedim,Number> and so on.
Definition at line 58 of file derivative_form.h.
@@ 393,7 +393,7 @@Converts a DerivativeForm <order, dim, dim, Number> to Tensor<order+1, dim, Number>. In particular, if order == 1 and the derivative is the Jacobian of
Converts a DerivativeForm <order, dim, dim, Number> to Tensor<order+1, dim, Number>. In particular, if order == 1 and the derivative is the Jacobian of
Compute the Frobenius norm of this form, i.e., the expression
Compute the Frobenius norm of this form, i.e., the expression
Compute the volume element associated with the jacobian of the transformation
Compute the volume element associated with the jacobian of the transformation
Assuming that the current object stores the Jacobian of a mapping
Assuming that the current object stores the Jacobian of a mapping
Auxiliary function that computes
Auxiliary function that computes
One of the uses of DerivativeForm is to apply it as a linear transformation. This function returns

+
The transformation corresponds to

in index notation and corresponds to
in index notation and corresponds to
Definition at line 454 of file derivative_form.h.
@@ 625,7 +625,7 @@Similar to the previous apply_transformation(). Each row of the result corresponds to one of the rows of D_X
transformed by grad_F
, equivalent to
Similar to the previous apply_transformation(). Each row of the result corresponds to one of the rows of D_X
transformed by grad_F
, equivalent to
Definition at line 479 of file derivative_form.h.
@@ 655,7 +655,7 @@Similar to the previous apply_transformation(), specialized for the case dim == spacedim
where we can return a rank2 tensor instead of the more general DerivativeForm
. Each row of the result corresponds to one of the rows of D_X
transformed by grad_F
, equivalent to
Similar to the previous apply_transformation(), specialized for the case dim == spacedim
where we can return a rank2 tensor instead of the more general DerivativeForm
. Each row of the result corresponds to one of the rows of D_X
transformed by grad_F
, equivalent to
Definition at line 505 of file derivative_form.h.
@@ 715,11 +715,11 @@Similar to the previous apply_transformation(). In matrix notation, it computes

+
Definition at line 565 of file derivative_form.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classDifferentiation_1_1AD_1_1CellLevelBase.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classDifferentiation_1_1AD_1_1CellLevelBase.html 20240412 04:45:50.783569815 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDifferentiation_1_1AD_1_1CellLevelBase.html 20240412 04:45:50.791569870 +0000 @@ 514,7 +514,7 @@Compute the value of the residual vector field
Compute the value of the residual vector field
[out]  residual  A Vector object with the value for each component of the vector field evaluated at the point defined by the independent variable values. 
Compute the gradient (first derivative) of the residual vector field with respect to all independent variables, i.e.

Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
The constructor for the class.
[in]  index  The index of the entry in the global list of dependent variables that this function belongs to. 
[in]  n_independent_variables  The number of independent variables that will be used in the definition of the functions that it is desired to compute the sensitivities of. In the computation of 
[in]  n_independent_variables  The number of independent variables that will be used in the definition of the functions that it is desired to compute the sensitivities of. In the computation of 
Definition at line 793 of file ad_helpers.cc.
@@ 495,7 +495,7 @@Register the definition of the total cell energy
Register the definition of the total cell energy
[in]  energy  A recorded function that defines the total cell energy. This represents the single dependent variable from which both the residual and its linearization are to be computed. 
Evaluation of the total scalar energy functional for a chosen set of degree of freedom values, i.e.

The values at the evaluation point
Evaluation of the residual for a chosen set of degree of freedom values. Underlying this is the computation of the gradient (first derivative) of the scalar function

+
The values at the evaluation point
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

+
The values at the evaluation point
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
[in]  index  The index of the entry in the global list of dependent variables that this function belongs to. 
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
[in]  index  The index of the entry in the global list of dependent variables that this function belongs to.  
const ExtractorType &  extractor&#href_anchor"memdoc">
 Register the subset of independent variables Register the subset of independent variables

Register the definition of the cell residual vector
Register the definition of the cell residual vector
[in]  residual  A vector of recorded functions that defines the residual. The components of this vector represents the dependent variables. 
Evaluation of the residual for a chosen set of degree of freedom values. This corresponds to the computation of the residual vector, i.e.

The values at the evaluation point
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

+
The values at the evaluation point
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
[in]  index  The index of the entry in the global list of dependent variables that this function belongs to. 
Register the definition of the scalar field
Register the definition of the scalar field
[in]  func  The recorded function that defines a dependent variable. 
Compute the value of the scalar field
Compute the value of the scalar field
Definition at line 1348 of file ad_helpers.cc.
@@ 575,9 +575,9 @@Compute the gradient (first derivative) of the scalar field with respect to all independent variables, i.e.

Compute the Hessian (second derivative) of the scalar field with respect to all independent variables, i.e.

Extract the function gradient for a subset of independent variables

+
Extract the function Hessian for a subset of independent variables

+
Extract the function Hessian for a subset of independent variables

+
This function is a specialization of the above for rank0 tensors (scalars). This corresponds to extracting a single entry of the Hessian matrix because both extractors imply selection of just a single row or column of the matrix.
@@ 794,11 +794,11 @@Extract the function Hessian for a subset of independent variables

+
This function is a specialization of the above for rank4 symmetric tensors.
@@ 919,7 +919,7 @@Register the subset of independent variables
Register the subset of independent variables
[in]  value  A field that defines a number of independent variables. When considering taped AD numbers with branching functions, to avoid potential issues with branch switching it may be a good idea to choose these values close or equal to those that will be later evaluated and differentiated around. 
Set the values for a subset of independent variables
Set the values for a subset of independent variables
[in]  value  A field that defines the values of a number of independent variables. 
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
[in]  index  The index of the entry in the global list of dependent variables that this function belongs to. 
Register the definition of the vector field
Register the definition of the vector field
[in]  funcs  A vector of recorded functions that defines the dependent variables.  
const ExtractorType &  extractor&#href_anchor"memdoc">
 Register the definition of the vector field Register the definition of the vector field

Extract the Jacobian of the subset of dependent functions

+
This function is a specialization of the above for rank4 symmetric tensors.
@@ 923,7 +923,7 @@Register the subset of independent variables
Register the subset of independent variables
[in]  value  A field that defines a number of independent variables. When considering taped AD numbers with branching functions, to avoid potential issues with branch switching it may be a good idea to choose these values close or equal to those that will be later evaluated and differentiated around. 
Set the values for a subset of independent variables
Set the values for a subset of independent variables
[in]  value  A field that defines the values of a number of independent variables. 
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Set the actual value of the independent variable
Set the actual value of the independent variable
[in]  index  The index in the vector of independent variables. 
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
Initialize an independent variable
[out]  out  An autodifferentiable number that is ready for use in standard computations. The operations that are performed with it are not recorded on the tape, and so should only be used when not in recording mode. 
Register the definition of the index'th dependent variable
Register the definition of the index'th dependent variable
Since time is marched forward in a discrete manner in our simulations, we need to discuss how we increment time. During time stepping we enter two separate alternating regimes in every step.
Tecplot
, Paraview
, and VisIt
. Additionally, during the snapshot stage, the code can assess the quality of the previous step and decide whether it wants to increase or decrease the time step size. The step size for the next time step can be modified here, by calling set_desired_next_step_size().The update stage (the transition stage, the inconsistent stage): In this section of the program, the internal state of the simulation is getting updated from
The update stage (the transition stage, the inconsistent stage): In this section of the program, the internal state of the simulation is getting updated from
The question arises whether time should be incremented before updating state quantities. Multiple possibilities exist, depending on program and formulation requirements, and possibly the programmer's preferences:
advance_time()
command that was performed previously. In the following example code, we are assuming that a
and b
are two state variables that need to be updated in this time step. [in]  index  The index of the entry in the global list of dependent variables that this function belongs to. 
Given a triangulation and a description of a finite element, this class enumerates degrees of freedom on all vertices, edges, faces, and cells of the triangulation. As a result, it also provides a basis for a discrete space
Given a triangulation and a description of a finite element, this class enumerates degrees of freedom on all vertices, edges, faces, and cells of the triangulation. As a result, it also provides a basis for a discrete space
It is first used in the step2 tutorial program.
For each 0d, 1d, 2d, and 3d subobject, this class stores a list of the indices of degrees of freedom defined on this DoFHandler. These indices refer to the unconstrained degrees of freedom, i.e. constrained degrees of freedom are numbered in the same way as unconstrained ones, and are only later eliminated. This leads to the fact that indices in global vectors and matrices also refer to all degrees of freedom and some kind of condensation is needed to restrict the systems of equations to the unconstrained degrees of freedom only. The actual layout of storage of the indices is described in the internal::DoFHandlerImplementation::DoFLevel class documentation.
The class offers iterators to traverse all cells, in much the same way as the Triangulation class does. Using the begin() and end() functions (and companions, like begin_active()), one can obtain iterators to walk over cells, and query the degree of freedom structures as well as the triangulation data. These iterators are built on top of those of the Triangulation class, but offer the additional information on degrees of freedom functionality compared to pure triangulation iterators. The order in which dof iterators are presented by the ++
and 
operators is the same as that for the corresponding iterators traversing the triangulation on which this DoFHandler is constructed.
Like many other classes in deal.II, the DoFHandler class can stream its contents to an archive using BOOST's serialization facilities. The data so stored can later be retrieved again from the archive to restore the contents of this object. This facility is frequently used to save the state of a program to disk for possible later resurrection, often in the context of checkpoint/restart strategies for long running computations or on computers that aren't very reliable (e.g. on very large clusters where individual nodes occasionally fail and then bring down an entire MPI job).
The model for doing so is similar for the DoFHandler class as it is for the Triangulation class (see the section in the general documentation of that class). In particular, the load() function does not exactly restore the same state as was stored previously using the save() function. Rather, the function assumes that you load data into a DoFHandler object that is already associated with a triangulation that has a content that matches the one that was used when the data was saved. Likewise, the load() function assumes that the current object is already associated with a finite element object that matches the one that was associated with it when data was saved; the latter can be achieved by calling DoFHandler::distribute_dofs() using the same kind of finite element before reloading data from the serialization archive.
Instead of only using one particular FiniteElement on all cells, this class also allows for an enumeration of degrees of freedom on different finite elements on every cells. To this end, one assigns an active_fe_index
to every cell that indicates which element within a collection of finite elements (represented by an object of type hp::FECollection) is the one that lives on this cell. The class then enumerates the degree of freedom associated with these finite elements on each cell of a triangulation and, if possible, identifies degrees of freedom at the interfaces of cells if they match. If neighboring cells have degrees of freedom along the common interface that do not immediate match (for example, if you have
Instead of only using one particular FiniteElement on all cells, this class also allows for an enumeration of degrees of freedom on different finite elements on every cells. To this end, one assigns an active_fe_index
to every cell that indicates which element within a collection of finite elements (represented by an object of type hp::FECollection) is the one that lives on this cell. The class then enumerates the degree of freedom associated with these finite elements on each cell of a triangulation and, if possible, identifies degrees of freedom at the interfaces of cells if they match. If neighboring cells have degrees of freedom along the common interface that do not immediate match (for example, if you have
The whole process of working with objects of this type is explained in step27. Many of the algorithms this class implements are described in the hppaper.
The typical workflow for using this class is to create a mesh, assign an active FE index to every active cell, call DoFHandler::distribute_dofs(), and then assemble a linear system and solve a problem on this finite element space.
@@ 983,7 +983,7 @@Go through the triangulation and "distribute" the degrees of freedom needed for the given finite element. "Distributing" degrees of freedom involves allocating memory to store the indices on all entities on which degrees of freedom can be located (e.g., vertices, edges, faces, etc.) and to then enumerate all degrees of freedom. In other words, while the mesh and the finite element object by themselves simply define a finite element space
Go through the triangulation and "distribute" the degrees of freedom needed for the given finite element. "Distributing" degrees of freedom involves allocating memory to store the indices on all entities on which degrees of freedom can be located (e.g., vertices, edges, faces, etc.) and to then enumerate all degrees of freedom. In other words, while the mesh and the finite element object by themselves simply define a finite element space
The exact order in which degrees of freedom on a mesh are ordered, i.e., the order in which basis functions of the finite element space are enumerated, is something that deal.II treats as an implementation detail. By and large, degrees of freedom are enumerated in the same order in which we traverse cells, but you should not rely on any specific numbering. In contrast, if you want a particular ordering, use the functions in namespace DoFRenumbering.
This function is first discussed in the introduction to the step2 tutorial program.
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of
Definition at line 567 of file dynamic_sparsity_pattern.cc.
/usr/share/doc/packages/dealii/doxygen/deal.II/classEigenInverse.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenInverse.html 20240412 04:45:51.391574025 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenInverse.html 20240412 04:45:51.399574081 +0000 @@ 191,7 +191,7 @@Inverse iteration (Wieland) for eigenvalue computations.
This class implements an adaptive version of the inverse iteration by Wieland.
There are two choices for the stopping criterion: by default, the norm of the residual
There are two choices for the stopping criterion: by default, the norm of the residual
Usually, the initial guess entering this method is updated after each step, replacing it with the new approximation of the eigenvalue. Using a parameter AdditionalData::relaxation between 0 and 1, this update can be damped. With relaxation parameter 0, no update is performed. This damping allows for slower adaption of the shift value to make sure that the method converges to the eigenvalue closest to the initial guess. This can be aided by the parameter AdditionalData::start_adaption, which indicates the first iteration step in which the shift value should be adapted.
Definition at line 129 of file eigen.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classEigenPower.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenPower.html 20240412 04:45:51.435574330 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenPower.html 20240412 04:45:51.439574358 +0000 @@ 190,7 +190,7 @@Power method (von Mises) for eigenvalue computations.
This method determines the largest eigenvalue of a matrix by applying increasing powers of this matrix to a vector. If there is an eigenvalue
This method determines the largest eigenvalue of a matrix by applying increasing powers of this matrix to a vector. If there is an eigenvalue
A shift parameter allows to shift the spectrum, so it is possible to compute the smallest eigenvalue, too.
Convergence of this method is known to be slow.
/usr/share/doc/packages/dealii/doxygen/deal.II/classEllipticalManifold.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classEllipticalManifold.html 20240412 04:45:51.491574718 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEllipticalManifold.html 20240412 04:45:51.499574773 +0000 @@ 223,16 +223,16 @@Elliptical manifold description derived from ChartManifold. More information on the elliptical coordinate system can be found at Wikipedia .
This is based on the definition of elliptic coordinates

+
in which
The current implementation uses coordinates
in which
The current implementation uses coordinates
The constructor of this class will throw an exception if both dim and spacedim are different from two.
This manifold can be used to produce hyper_shells with elliptical curvature. As an example, the test elliptical_manifold_01 produces the following triangulation:
center  Center of the manifold. 
major_axis_direction  Direction of the major axis of the manifold. 
eccentricity  Eccentricity of the manifold 
eccentricity  Eccentricity of the manifold 
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
This function is used in the computations required by the get_tangent_vector() function. Since not all users of the Manifold class interface will require calling that function, the current function is implemented but will trigger an exception whenever called. This allows derived classes to avoid implementing the push_forward_gradient function if this functionality is not needed in the user program.
Refer to the general documentation of this class for more information.
@@ 520,7 +520,7 @@Return the periodicity associated with the submanifold.
For
For
Definition at line 1244 of file manifold_lib.cc.
@@ 748,7 +748,7 @@Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function
This function is used in the computations required by the get_tangent_vector() function. Since not all users of the Manifold class interface will require calling that function, the current function is implemented but will trigger an exception whenever called. This allows derived classes to avoid implementing the push_forward_gradient function if this functionality is not needed in the user program.
Refer to the general documentation of this class for more information.
@@ 782,24 +782,24 @@Return a vector that, at
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are

For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the preimages of x1
and x2
(where preimages are computed by pulling back the locations x1
and x2
). In other words, if these preimages are
+
In image space, i.e., in the space in which we operate, this leads to the curve

What the current function is supposed to return is

+
This formula may then have to be slightly modified by considering any periodicity that was assumed in the call to the constructor.
Thus, the computation of tangent vectors also requires the implementation of derivatives
Thus, the computation of tangent vectors also requires the implementation of derivatives
Likewise, a gradient of the finite element solution represented by vector
can be interpolated to the quadrature points by fe_eval.get_gradient(q)
. The combination of read_dof_values(), evaluate() and get_value() is similar to what FEValues::get_function_values or FEValues::get_function_gradients does, but it is in general much faster because it makes use of the tensor product, see the description of the evaluation routines below, and can do this operation for several cells at once through vectorization.
The second class of tasks done by FEEvaluation are integration tasks for right hand sides. In finite element computations, these typically consist of multiplying a quantity on quadrature points (a function value, or a field interpolated by the finite element space itself) by a set of test functions and integrating over the cell through summation of the values in each quadrature point, multiplied by the quadrature weight and the Jacobian determinant of the transformation. If a generic Function object is given and we want to compute
The second class of tasks done by FEEvaluation are integration tasks for right hand sides. In finite element computations, these typically consist of multiplying a quantity on quadrature points (a function value, or a field interpolated by the finite element space itself) by a set of test functions and integrating over the cell through summation of the values in each quadrature point, multiplied by the quadrature weight and the Jacobian determinant of the transformation. If a generic Function object is given and we want to compute
x1  The first point that describes the geodesic, and the one at which the "direction" is to be evaluated. 
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the inverse and transposed version
Return the inverse and transposed version
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
Return the inverse and transposed version
Return the inverse and transposed version
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
Return the derivative of a finite element function at quadrature point number q_point
after a call to FEEvaluation::evaluate(EvaluationFlags::gradients) the direction normal to the face:
This call is equivalent to calling get_gradient() * normal_vector() but will use a more efficient internal representation of data.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the curl of the vector field, evaluate(EvaluationFlags::gradients)
.
Return the inverse and transposed version
Return the inverse and transposed version
If the shape function is vectorvalued, then this returns the only non zero component. If the shape function has more than one nonzero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated 
Compute one vector component of the value of a shape function at a quadrature point. If the finite element is scalar, then only component zero is allowed and the return value equals that of the shape_value() function. If the finite element is vector valued but all shape functions are primitive (i.e. they are nonzero in only one component), then the value returned by shape_value() equals that of this function for exactly one component. This function is therefore only of greater interest if the shape function is not primitive, but then it is necessary since the other function cannot be used.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
component  vector component to be evaluated. 
The same holds for the arguments of this function as for the shape_value() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
If the current cell is not active (i.e., it has children), then the finite element function is, strictly speaking, defined by shape functions that live on these child cells. Rather than evaluating the shape functions on the child cells, with the quadrature points defined on the current cell, this function first interpolates the finite element function to shape functions defined on the current cell, and then evaluates this interpolated function.
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. To get values of multicomponent elements, there is another get_function_values() below, returning a vector of vectors of results.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
values[q]
will contain the value of the field described by fe_function at the values[q]
will contain the value of the field described by fe_function at the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_values(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3320 of file fe_values.cc.
@@ 1431,16 +1431,16 @@Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. There is a corresponding function of the same name for vectorvalued finite elements.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_gradients(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3463 of file fe_values.cc.
@@ 1595,11 +1595,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_hessians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3576 of file fe_values.cc.
@@ 1759,11 +1759,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]=trace(hessians[q])
, where hessians
would be the output of the get_function_hessians() function.This function does the same as the other get_function_laplacians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q][c]=trace(hessians[q][c])
, where hessians
would be the output of the get_function_hessians() function.update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. [in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_third_derivatives(), but applied to multicomponent (vector valued) elements. The meaning of the arguments is as explained there.
third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3826 of file fe_values.cc.
@@ 2350,7 +2350,7 @@Mapped quadrature weight. If this object refers to a volume evaluation (i.e. the derived class is of type FEValues), then this is the Jacobi determinant times the weight of the q_point
th unit quadrature point.
For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues), it is the mapped surface element times the weight of the quadrature point.
You can think of the quantity returned by this function as the volume or surface element
You can think of the quantity returned by this function as the volume or surface element
update_JxW_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the Jacobian of the transformation at the specified quadrature point, i.e.
Return the Jacobian of the transformation at the specified quadrature point, i.e.
update_jacobians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
update_jacobian_pushed_forward_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_2nd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. If the shape function is vectorvalued, then this returns the only non zero component. If the shape function has more than one nonzero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated 
Compute one vector component of the value of a shape function at a quadrature point. If the finite element is scalar, then only component zero is allowed and the return value equals that of the shape_value() function. If the finite element is vector valued but all shape functions are primitive (i.e. they are nonzero in only one component), then the value returned by shape_value() equals that of this function for exactly one component. This function is therefore only of greater interest if the shape function is not primitive, but then it is necessary since the other function cannot be used.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
component  vector component to be evaluated. 
The same holds for the arguments of this function as for the shape_value() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
If the current cell is not active (i.e., it has children), then the finite element function is, strictly speaking, defined by shape functions that live on these child cells. Rather than evaluating the shape functions on the child cells, with the quadrature points defined on the current cell, this function first interpolates the finite element function to shape functions defined on the current cell, and then evaluates this interpolated function.
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. To get values of multicomponent elements, there is another get_function_values() below, returning a vector of vectors of results.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
values[q]
will contain the value of the field described by fe_function at the values[q]
will contain the value of the field described by fe_function at the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_values(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3320 of file fe_values.cc.
@@ 1149,16 +1149,16 @@Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. There is a corresponding function of the same name for vectorvalued finite elements.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_gradients(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3463 of file fe_values.cc.
@@ 1313,11 +1313,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_hessians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3576 of file fe_values.cc.
@@ 1477,11 +1477,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]=trace(hessians[q])
, where hessians
would be the output of the get_function_hessians() function.This function does the same as the other get_function_laplacians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q][c]=trace(hessians[q][c])
, where hessians
would be the output of the get_function_hessians() function.update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. [in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_third_derivatives(), but applied to multicomponent (vector valued) elements. The meaning of the arguments is as explained there.
third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3826 of file fe_values.cc.
@@ 2068,7 +2068,7 @@Mapped quadrature weight. If this object refers to a volume evaluation (i.e. the derived class is of type FEValues), then this is the Jacobi determinant times the weight of the q_point
th unit quadrature point.
For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues), it is the mapped surface element times the weight of the quadrature point.
You can think of the quantity returned by this function as the volume or surface element
You can think of the quantity returned by this function as the volume or surface element
update_JxW_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the Jacobian of the transformation at the specified quadrature point, i.e.
Return the Jacobian of the transformation at the specified quadrature point, i.e.
update_jacobians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
update_jacobian_pushed_forward_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_2nd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. q_index
and mapping_index
arguments to this function are explicitly specified (rather than leaving them at their default values), then these indices will be used to select which element of the hp::QCollection and hp::MappingCollection passed to the constructor should serve as the quadrature and mapping to be used.active_fe_index
values of the two adjacent cells are identical (i.e., have quadrature points at the same locations, and have the same weights). If this is so, then it does not matter which one of the two we take, and we choose one or the other.q_index
and mapping_index
arguments to this function.Mapped quadrature weight. This value equals the mapped surface element times the weight of the quadrature point.
You can think of the quantity returned by this function as the surface element
You can think of the quantity returned by this function as the surface element
update_JxW_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump interface_dof_index
at the quadrature point q_point
of component component
.
Return the jump interface_dof_index
at the quadrature point q_point
of component component
.
Note that one can define the jump in different ways (the value "there" minus the value "here", or the other way around; both are used in the finite element literature). The definition here uses "value here minus value there", as seen from the first cell.
If this is a boundary face (at_boundary() returns true), then
If this is a boundary face (at_boundary() returns true), then
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the jump in the Hessian interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the jump in the Hessian interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the average interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the average interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the average of the gradient interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the average of the gradient interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
Return the average of the Hessian interface_dof_index
at the quadrature point q_point
of component component
.
If this is a boundary face (at_boundary() returns true), then
interface_dof_index
at the quadrature point q_point
of component component
.
+If this is a boundary face (at_boundary() returns true), then
Return the jump interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the jump interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the jump of the gradient interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the jump of the gradient interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the average value interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the average value interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the average of the gradient interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the average of the gradient interface_dof_index
in the quadrature point q_point
of the component selected by this view.
Return the average of the Hessian interface_dof_index
at the quadrature point q_point
of the component selected by this view.
interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the values of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The argument here_or_there
selects between the value on cell 0 (here, true
) and cell 1 (there, false
). You can also interpret it as "upstream" (true
) and "downstream" (false
) as defined by the direction of the normal vector in this quadrature point. If here_or_there
is true, the values from the first cell of the interface is used.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the values of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the gradients of the selected scalar components of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the Hessians of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the third derivatives of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the third derivatives of shape functions (i.e., third_derivative_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the third derivatives of shape functions (i.e., third_derivative_type
) times the type used to store the values of the unknowns fe_function
argument).
update_third_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the values of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the gradients of the selected scalar components of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the Hessians of the selected scalar component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump vector interface_dof_index
in the quadrature point q_point
.
Return the jump vector interface_dof_index
in the quadrature point q_point
.
Return the jump of the gradient (a tensor of rank 2) interface_dof_index
in the quadrature point q_point
.
Return the jump of the gradient (a tensor of rank 2) interface_dof_index
in the quadrature point q_point
.
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the gradient interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the jump in the third derivative interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the average vector interface_dof_index
in the quadrature point q_point
.
Return the average vector interface_dof_index
in the quadrature point q_point
.
Return the average of the gradient (a tensor of rank 2) interface_dof_index
in the quadrature point q_point
.
Return the average of the gradient (a tensor of rank 2) interface_dof_index
in the quadrature point q_point
.
Return the average of the Hessian interface_dof_index
at the quadrature point q_point
of the component selected by this view.
interface_dof_index
at the quadrature point q_point
of the component selected by this view.
Return the values of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The argument here_or_there
selects between the value on cell 0 (here, true
) and cell 1 (there, false
). You can also interpret it as "upstream" (true
) and "downstream" (false
) as defined by the direction of the normal vector in this quadrature point. If here_or_there
is true, the values from the first cell of the interface is used.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the values of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the gradients of the selected vector components of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the Hessians of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the jump in the third derivatives of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the third derivatives of shape functions (i.e., third_derivative_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the third derivatives of shape functions (i.e., third_derivative_type
) times the type used to store the values of the unknowns fe_function
argument).
update_third_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the values of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the values of shape functions (i.e., value_type
) times the type used to store the values of the unknowns fe_function
argument).
update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the gradients of the selected vector components of the finite element function characterized by fe_function
at the quadrature points of the cell interface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the gradients of shape functions (i.e., gradient_type
) times the type used to store the values of the unknowns fe_function
argument).
update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the average of the Hessians of the selected vector component of the finite element function characterized by fe_function
at the quadrature points of the cell, face or subface selected the last time the reinit
function of the FEInterfaceValues object was called.
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
The data type stored by the output vector must be what you get when you multiply the Hessians of shape functions (i.e., hessian_type
) times the type used to store the values of the unknowns fe_function
argument).
update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. A class to calculate expansion of a scalar FE (or a single component of vectorvalued FE) field into Fourier series on a reference element. The exponential form of the Fourier series is based on completeness and Hermitian orthogonality of the set of exponential functions

+
Note that
Note that
The arbitrary scalar FE field on the reference element can be expanded in the complete orthogonal exponential basis as

From the orthogonality property of the basis, it follows that

It is this complexvalued expansion coefficients, that are calculated by this class. Note that
It is this complexvalued expansion coefficients, that are calculated by this class. Note that
Definition at line 90 of file fe_series.h.
Angular frequencies
Angular frequencies
Definition at line 196 of file fe_series.h.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFESeries_1_1Legendre.html differs (HTML document, ASCII text, with very long lines)  old//usr/share/doc/packages/dealii/doxygen/deal.II/classFESeries_1_1Legendre.html 20240412 04:45:52.799583773 +0000 +++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFESeries_1_1Legendre.html 20240412 04:45:52.799583773 +0000 @@ 196,39 +196,39 @@A class to calculate expansion of a scalar FE (or a single component of vectorvalued FE) field into series of Legendre functions on a reference element.
Legendre functions are solutions to Legendre's differential equation

and can be expressed using Rodrigues' formula

These polynomials are orthogonal with respect to the

+
and are complete. A family of

+
An arbitrary scalar FE field on the reference element

+
From the orthogonality property of the basis, it follows that

This class calculates coefficients
This class calculates coefficients
Definition at line 260 of file fe_series.h.
If the shape function is vectorvalued, then this returns the only non zero component. If the shape function has more than one nonzero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated 
Compute one vector component of the value of a shape function at a quadrature point. If the finite element is scalar, then only component zero is allowed and the return value equals that of the shape_value() function. If the finite element is vector valued but all shape functions are primitive (i.e. they are nonzero in only one component), then the value returned by shape_value() equals that of this function for exactly one component. This function is therefore only of greater interest if the shape function is not primitive, but then it is necessary since the other function cannot be used.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
component  vector component to be evaluated. 
The same holds for the arguments of this function as for the shape_value() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
If the current cell is not active (i.e., it has children), then the finite element function is, strictly speaking, defined by shape functions that live on these child cells. Rather than evaluating the shape functions on the child cells, with the quadrature points defined on the current cell, this function first interpolates the finite element function to shape functions defined on the current cell, and then evaluates this interpolated function.
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. To get values of multicomponent elements, there is another get_function_values() below, returning a vector of vectors of results.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
values[q]
will contain the value of the field described by fe_function at the values[q]
will contain the value of the field described by fe_function at the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_values(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3320 of file fe_values.cc.
@@ 1459,16 +1459,16 @@Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. There is a corresponding function of the same name for vectorvalued finite elements.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_gradients(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3463 of file fe_values.cc.
@@ 1623,11 +1623,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_hessians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3576 of file fe_values.cc.
@@ 1787,11 +1787,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]=trace(hessians[q])
, where hessians
would be the output of the get_function_hessians() function.This function does the same as the other get_function_laplacians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q][c]=trace(hessians[q][c])
, where hessians
would be the output of the get_function_hessians() function.update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. [in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_third_derivatives(), but applied to multicomponent (vector valued) elements. The meaning of the arguments is as explained there.
third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3826 of file fe_values.cc.
@@ 2378,7 +2378,7 @@Mapped quadrature weight. If this object refers to a volume evaluation (i.e. the derived class is of type FEValues), then this is the Jacobi determinant times the weight of the q_point
th unit quadrature point.
For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues), it is the mapped surface element times the weight of the quadrature point.
You can think of the quantity returned by this function as the volume or surface element
You can think of the quantity returned by this function as the volume or surface element
update_JxW_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the Jacobian of the transformation at the specified quadrature point, i.e.
Return the Jacobian of the transformation at the specified quadrature point, i.e.
update_jacobians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
update_jacobian_pushed_forward_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_2nd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This class provides an interface to group several elements together into one, vectorvalued element. As example, consider the TaylorHood element that is used for the solution of the Stokes and NavierStokes equations: There, the velocity (of which there are as many components as the dimension
This class provides an interface to group several elements together into one, vectorvalued element. As example, consider the TaylorHood element that is used for the solution of the Stokes and NavierStokes equations: There, the velocity (of which there are as many components as the dimension
The creation of this element here corresponds to taking tensorproduct powers of the
The creation of this element here corresponds to taking tensorproduct powers of the
Similarly, step8 solves an elasticity equation where we need to solve for the displacement of a solid object. The displacement again has
where now each (vector) component of the combined element corresponds to a
To the outside world, FESystem objects look just like a usual finite element object, they just happen to be composed of several other finite elements that are possibly of different type. These "base elements" can themselves have multiple components and, in particular, could also be vectorvalued – for example, if one of the base elements is an FESystem itself (see also below). An example is given in the documentation of namespace FETools::Compositing, when using the "tensor product" strategy.
@@ 3836,7 +3836,7 @@Return a block mask with as many elements as this object has blocks and of which exactly the one component is true that corresponds to the given argument. See the glossary for more information.
scalar  An object that represents a single scalar vector component of this finite element. 
Given a component mask (see this glossary entry), produce a block mask (see this glossary entry) that represents the blocks that correspond to the components selected in the input argument. This is essentially a conversion operator from ComponentMask to BlockMask.
component_mask  The mask that selects individual components of the finite element 
For a given degree of freedom, return whether it is logically associated with a vertex, line, quad or hex.
For instance, for continuous finite elements this coincides with the lowest dimensional object the support point of the degree of freedom lies on. To give an example, for
To make this more formal, the kind of object returned by this function represents the object so that the support of the shape function corresponding to the degree of freedom, (i.e., that part of the domain where the function "lives") is the union of all of the cells sharing this object. To return to the example above, for
On the other hand, for discontinuous elements of type
For instance, for continuous finite elements this coincides with the lowest dimensional object the support point of the degree of freedom lies on. To give an example, for
To make this more formal, the kind of object returned by this function represents the object so that the support of the shape function corresponding to the degree of freedom, (i.e., that part of the domain where the function "lives") is the union of all of the cells sharing this object. To return to the example above, for
On the other hand, for discontinuous elements of type
If the shape function is vectorvalued, then this returns the only non zero component. If the shape function has more than one nonzero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
[in]  cell_dof_index  The index of a shape function or degree of freedom. This index must be in the range [0,dofs_per_cell) . 
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated 
Compute one vector component of the value of a shape function at a quadrature point. If the finite element is scalar, then only component zero is allowed and the return value equals that of the shape_value() function. If the finite element is vector valued but all shape functions are primitive (i.e. they are nonzero in only one component), then the value returned by shape_value() equals that of this function for exactly one component. This function is therefore only of greater interest if the shape function is not primitive, but then it is necessary since the other function cannot be used.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
component  vector component to be evaluated. 
The same holds for the arguments of this function as for the shape_value() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
If the current cell is not active (i.e., it has children), then the finite element function is, strictly speaking, defined by shape functions that live on these child cells. Rather than evaluating the shape functions on the child cells, with the quadrature points defined on the current cell, this function first interpolates the finite element function to shape functions defined on the current cell, and then evaluates this interpolated function.
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. To get values of multicomponent elements, there is another get_function_values() below, returning a vector of vectors of results.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
values[q]
will contain the value of the field described by fe_function at the values[q]
will contain the value of the field described by fe_function at the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_values(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3320 of file fe_values.cc.
@@ 1243,16 +1243,16 @@Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. There is a corresponding function of the same name for vectorvalued finite elements.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_gradients(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3463 of file fe_values.cc.
@@ 1407,11 +1407,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_hessians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3576 of file fe_values.cc.
@@ 1571,11 +1571,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]=trace(hessians[q])
, where hessians
would be the output of the get_function_hessians() function.This function does the same as the other get_function_laplacians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the laplacians[q][c]=trace(hessians[q][c])
, where hessians
would be the output of the get_function_hessians() function.update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. [in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  third_derivatives  The third derivatives of the function specified by fe_function at the quadrature points of the current cell. The third derivatives are computed in real space (as opposed to on the unit cell). The object is assumed to already have the correct size. The data type stored by this output vector must be what you get when you multiply the third derivatives of shape function times the type used to store the values of the unknowns fe_function argument). 
third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the third_derivatives[q]
will contain the third derivatives of the field described by fe_function at the third_derivatives[q][i][j][k]
represents the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_third_derivatives(), but applied to multicomponent (vector valued) elements. The meaning of the arguments is as explained there.
third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the third_derivatives[q]
is a vector of third derivatives of the field described by fe_function at the third_derivatives[q]
equals the number of components of the finite element, i.e. third_derivatives[q][c]
returns the third derivative of the third_derivatives[q][c][i][j][k]
is the update_3rd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3826 of file fe_values.cc.
@@ 2162,7 +2162,7 @@Mapped quadrature weight. If this object refers to a volume evaluation (i.e. the derived class is of type FEValues), then this is the Jacobi determinant times the weight of the q_point
th unit quadrature point.
For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues), it is the mapped surface element times the weight of the quadrature point.
You can think of the quantity returned by this function as the volume or surface element
You can think of the quantity returned by this function as the volume or surface element
update_JxW_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the Jacobian of the transformation at the specified quadrature point, i.e.
Return the Jacobian of the transformation at the specified quadrature point, i.e.
update_jacobians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
Return the second derivative of the transformation from unit to real cell, i.e. the first derivative of the Jacobian, at the specified quadrature point, pushed forward to the real cell coordinates, i.e.
update_jacobian_pushed_forward_grads
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
Return the third derivative of the transformation from unit to real cell, i.e. the second derivative of the Jacobian, at the specified quadrature point, i.e.
update_jacobian_2nd_derivatives
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. If the shape function is vectorvalued, then this returns the only non zero component. If the shape function has more than one nonzero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated 
Compute one vector component of the value of a shape function at a quadrature point. If the finite element is scalar, then only component zero is allowed and the return value equals that of the shape_value() function. If the finite element is vector valued but all shape functions are primitive (i.e. they are nonzero in only one component), then the value returned by shape_value() equals that of this function for exactly one component. This function is therefore only of greater interest if the shape function is not primitive, but then it is necessary since the other function cannot be used.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
component  vector component to be evaluated. 
The same holds for the arguments of this function as for the shape_value() function.
i  Number of the shape function 
i  Number of the shape function 
q_point  Number of the quadrature point at which function is to be evaluated. 
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the values of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
If the current cell is not active (i.e., it has children), then the finite element function is, strictly speaking, defined by shape functions that live on these child cells. Rather than evaluating the shape functions on the child cells, with the quadrature points defined on the current cell, this function first interpolates the finite element function to shape functions defined on the current cell, and then evaluates this interpolated function.
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. To get values of multicomponent elements, there is another get_function_values() below, returning a vector of vectors of results.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
[out]  values  The values of the function specified by fe_function at the quadrature points of the current cell. The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the values of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the solution vector. 
values[q]
will contain the value of the field described by fe_function at the values[q]
will contain the value of the field described by fe_function at the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_values(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the values[q]
is a vector of values of the field described by fe_function at the values[q]
equals the number of components of the finite element, i.e. values[q](c)
returns the value of the update_values
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3320 of file fe_values.cc.
@@ 1022,16 +1022,16 @@ std::vector< Tensor< 1, spacedim, typename InputVector::value_type > > & gradients&#href_anchor"memdoc"> Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
Return the gradients of a finite element function at the quadrature points of the current cell, face, or subface (selected the last time the reinit() function was called). That is, if the first argument fe_function
is a vector of nodal values of a finite element function values
) is the vector of values
This function may only be used if the finite element in use is a scalar one, i.e. has only one vector component. There is a corresponding function of the same name for vectorvalued finite elements.
[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  gradients  The gradients of the function specified by fe_function at the quadrature points of the current cell. The gradients are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the gradients of shape function times the type used to store the values of the unknowns fe_function argument). 
gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction gradients[q]
will contain the gradient of the field described by fe_function at the gradients[q][d]
represents the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_gradients(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction gradients[q]
is a vector of gradients of the field described by fe_function at the gradients[q]
equals the number of components of the finite element, i.e. gradients[q][c]
returns the gradient of the gradients[q][c][d]
is the derivative in coordinate direction update_gradients
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3463 of file fe_values.cc.
@@ 1158,11 +1158,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
[out]  hessians  The Hessians of the function specified by fe_function at the quadrature points of the current cell. The Hessians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Hessians of shape function times the type used to store the values of the unknowns fe_function argument). 
hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the hessians[q]
will contain the Hessian of the field described by fe_function at the hessians[q][i][j]
represents the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. This function does the same as the other get_function_hessians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the hessians[q]
is a vector of Hessians of the field described by fe_function at the hessians[q]
equals the number of components of the finite element, i.e. hessians[q][c]
returns the Hessian of the hessians[q][c][i][j]
is the update_hessians
flag must be an element of the list of UpdateFlags that you passed to the constructor of this object. See The interplay of UpdateFlags, Mapping, and FiniteElement in FEValues for more information. Definition at line 3576 of file fe_values.cc.
@@ 1294,11 +1294,11 @@[in]  fe_function  A vector of values that describes (globally) the finite element function that this function should evaluate at the quadrature points of the current cell. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
[out]  laplacians  The Laplacians of the function specified by fe_function at the quadrature points of the current cell. The Laplacians are computed in real space (as opposed to on the unit cell). The object is assume to already have the correct size. The data type stored by this output vector must be what you get when you multiply the Laplacians of shape function times the type used to store the values of the unknowns fe_function argument). This happens to be equal to the type of the elements of the input vector. 
laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]
will contain the Laplacian of the field described by fe_function at the laplacians[q]=trace(hessians[q])
, where hessians
would be the output of the get_function_hessians() function.This function does the same as the other get_function_laplacians(), but applied to multicomponent (vectorvalued) elements. The meaning of the arguments is as explained there.
laplacians[q]
is a vector of Laplacians of the field described by fe_function at the laplacians[q]
equals the number of components of the finite element, i.e. laplacians[q][c]
returns the Laplacian of the