It is often convenient to treat a matrix or vector as a collection of individual blocks. For example, in step-20 (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 step-20), 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 topic. 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 sub-blocks that can be individually addressed. Depending on context, one may wish to use one or the other interface.
Typically, one defines the sub-structure 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).
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 vector-valued solution function (or, equivalently, in terms of the vector-valued 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 step-22 or step-31 tutorial programs, as opposed to step-20). 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 step-22 or step-31 tutorial programs, as opposed to step-20). 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 topic 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.
@@ -177,14 +177,14 @@
Boundary form
For a dim-dimensional triangulation in dim-dimensional 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.
Boundary indicator
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 :
for (auto &face : triangulation.active_face_iterators())
+
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 :
for (auto &face : triangulation.active_face_iterators())
if (face->at_boundary())
if (face->center()[0] == -1)
face->set_boundary_id (42);
@@ -257,7 +257,7 @@
Component
-
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 vector-valued solution. For example, the vector solution in the elasticity equation considered in step-8 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 step-22 has four elements: . We call the elements of the vector-valued solution components in deal.II. To be well-posed, 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 topic.
+
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 vector-valued solution. For example, the vector solution in the elasticity equation considered in step-8 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 step-22 has four elements: . We call the elements of the vector-valued solution components in deal.II. To be well-posed, 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 topic.
In finite element programs, one frequently wants to address individual elements (components) of this vector-valued solution, or sets of components. For example, we do this extensively in step-8, and a lot of documentation is also provided in the topic 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 non-primitive 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.
would result in a mask [true, true, false] in 2d. Of course, in 3d, the result would be [true, true, true, false].
Note
Just as one can think of composed elements as being made up of components or blocks, there are component masks (represented by the ComponentMask class) and block masks (represented by the BlockMask class). The FiniteElement class has functions that convert between the two kinds of objects.
-Not all component masks actually make sense. For example, if you have a FE_RaviartThomas object in 2d, then it doesn't make any sense to have a component mask of the form [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.
+Not all component masks actually make sense. For example, if you have a FE_RaviartThomas object in 2d, then it doesn't make any sense to have a component mask of the form [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.
Compressing distributed vectors and matrices
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.
@@ -321,9 +321,9 @@
Degree of freedom
-
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.
Direction flags
@@ -345,7 +345,7 @@
Distorted cells
A distorted cell is a cell for which the mapping from the reference cell to real cell has a Jacobian whose determinant is non-positive 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 well-shaped. 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 well-shaped. 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 well-formed, a pinched, and a twisted cell for both 2d and 3d:
@@ -384,19 +384,19 @@
Generalized support points
-
"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 Raviart-Thomas element (see the FE_RaviartThomas class), the node functional evaluates not individual components of a vector-valued finite element function with dim components, but the normal component of this vector: "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 Raviart-Thomas element (see the FE_RaviartThomas class), the node functional evaluates not individual components of a vector-valued finite element function with dim components, but the normal component of this vector: , where the are the normal vectors to the face of the cell on which is located. In other words, the node functional is a linear combination of the components of when evaluated at . Similar things happen for the BDM, ABF, and Nedelec elements (see the FE_BDM, FE_ABF, FE_Nedelec classes).
-
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 . In these cases, we call the points generalized support 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, , where the are the normal vectors to the face of the cell on which is located. In other words, the node functional is a linear combination of the components of when evaluated at . Similar things happen for the BDM, ABF, and Nedelec elements (see the FE_BDM, FE_ABF, FE_Nedelec classes).
+
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 . In these cases, we call the points generalized support 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 2d, and similarly for 3d, where the are the order of the moment described by shape function . Some other elements use moments over edges or faces. In all of these cases, node functionals are not defined through interpolation at all, and these elements then have neither support points, nor generalized support points.
+ $" src="form_124.png"/> in 2d, and similarly for 3d, where the are the order of the moment described by shape function . Some other elements use moments over edges or faces. In all of these cases, node functionals are not defined through interpolation at all, and these elements then have neither support points, nor generalized support points.
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
-
+ \end{align*}" src="form_127.png"/>
-
in time step , where is the solution to be computed, is the known solution from the first time step, and is a matrix related to the differential operator in the PDE. is the size of the time step. A similar linear system of equations also arises out of the discretization of second-order differential equations.
-
The presence of the matrix on the left side is a nuisance because, even though we have used an explicit time stepping method, we still have to solve a linear system in each time step. It would be much preferable if the matrix were diagonal. "Lumping" the mass matrix is a strategy to replace by a matrix that actually is diagonal, yet does not destroy the accuracy of the resulting solution.
-
Historically, mass lumping was performed by adding the elements of a row together and setting the diagonal entries of to that sum. This works for and elements, for example, and can be understood mechanically by replacing the continuous medium we are discretizating by one where the continuous mass distribution is replaced by one where (finite amounts of) mass are located only at the nodes. That is, we are "lumping together" the mass of an element at its vertices, thus giving rise to the name "lumped mass matrix". A more mathematical perspective is to compute the integral above for via special quadrature rules; in particular, we replace the computation of
-, where is the solution to be computed, is the known solution from the first time step, and is a matrix related to the differential operator in the PDE. is the size of the time step. A similar linear system of equations also arises out of the discretization of second-order differential equations.
+
The presence of the matrix on the left side is a nuisance because, even though we have used an explicit time stepping method, we still have to solve a linear system in each time step. It would be much preferable if the matrix were diagonal. "Lumping" the mass matrix is a strategy to replace by a matrix that actually is diagonal, yet does not destroy the accuracy of the resulting solution.
+
Historically, mass lumping was performed by adding the elements of a row together and setting the diagonal entries of to that sum. This works for and elements, for example, and can be understood mechanically by replacing the continuous medium we are discretizating by one where the continuous mass distribution is replaced by one where (finite amounts of) mass are located only at the nodes. That is, we are "lumping together" the mass of an element at its vertices, thus giving rise to the name "lumped mass matrix". A more mathematical perspective is to compute the integral above for via special quadrature rules; in particular, we replace the computation of
+
+ \end{align*}" src="form_134.png"/>
by quadrature
-
+ \end{align*}" src="form_135.png"/>
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
-
+ \end{align*}" src="form_136.png"/>
and consequently
-
+ \end{align*}" src="form_137.png"/>
-
where the sum extends over those cells on which is nonzero. The so-computed mass matrix is therefore diagonal.
-
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 finite elements (implemented by FE_Q and FE_DGQ), the appropriate quadrature formulas are of QGaussLobatto type. Mass lumping can also be done with FE_SimplexP_Bubbles, for example, if appropriate quadrature rules are chosen.
+
where the sum extends over those cells on which is nonzero. The so-computed mass matrix is therefore diagonal.
+
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 finite elements (implemented by FE_Q and FE_DGQ), the appropriate quadrature formulas are of QGaussLobatto type. Mass lumping can also be done with FE_SimplexP_Bubbles, for example, if appropriate quadrature rules are chosen.
For an example of where lumped mass matrices play a role, see step-69.
Manifold indicator
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 component less than zero:
+
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 component less than zero:
for (auto &cell : triangulation.active_cell_iterators())
if (cell->center()[0] < 0)
cell->set_manifold_id (42);
@@ -557,41 +557,41 @@
Mass matrix
The "mass matrix" is a matrix of the form
-
+ \end{align*}" src="form_126.png"/>
-
possibly with a coefficient inside the integral, and where are the shape functions of a finite element. The origin of the term refers to the fact that in structural mechanics (where the finite element method originated), one often starts from the elastodynamics (wave) equation
- are the shape functions of a finite element. The origin of the term refers to the fact that in structural mechanics (where the finite element method originated), one often starts from the elastodynamics (wave) equation
+
/usr/share/doc/packages/dealii/doxygen/deal.II/Tutorial.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/Tutorial.html 2024-12-27 18:24:52.264760155 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/Tutorial.html 2024-12-27 18:24:52.268760182 +0000
@@ -345,7 +345,7 @@
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 pre-generated object. This turns an effort into an effort, where is the number of cells.
+
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 pre-generated object. This turns an effort into an effort, where is the number of cells.
(WB 2008/12/10)
/usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_6_2_and_6_3.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_6_2_and_6_3.html 2024-12-27 18:24:52.556762160 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_6_2_and_6_3.html 2024-12-27 18:24:52.564762215 +0000
@@ -514,7 +514,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_1_and_8_2.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_1_and_8_2.html 2024-12-27 18:24:52.596762435 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_1_and_8_2.html 2024-12-27 18:24:52.600762462 +0000
@@ -852,7 +852,7 @@
-
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 (and and ) values, for example to evaluate experimentally determined coefficients, or to assess the accuracy of a solution by comparing with a solution generated by a different code and written in gridded data. There is also a new class Functions::InterpolatedUniformGridData that can perform the same task more efficiently if the data is stored on meshes that are uniform in each coordinate direction.
+
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 (and and ) values, for example to evaluate experimentally determined coefficients, or to assess the accuracy of a solution by comparing with a solution generated by a different code and written in gridded data. There is also a new class Functions::InterpolatedUniformGridData that can perform the same task more efficiently if the data is stored on meshes that are uniform in each coordinate direction.
(Wolfgang Bangerth, 2013/12/20)
/usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_2_1_and_8_3.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_2_1_and_8_3.html 2024-12-27 18:24:52.636762709 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_8_2_1_and_8_3.html 2024-12-27 18:24:52.640762737 +0000
@@ -567,7 +567,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_9_1_1_and_9_2_0.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_9_1_1_and_9_2_0.html 2024-12-27 18:24:52.696763122 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/changes_between_9_1_1_and_9_2_0.html 2024-12-27 18:24:52.700763149 +0000
@@ -621,7 +621,7 @@
-
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 with a non-negative integer. The new cases and correspond to refinement in the azimuthal direction of the 6 or 12 cell case with a single mesh layer in radial direction, and are intended for shells that are thin and should be given more resolution in azimuthal direction.
+
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 with a non-negative integer. The new cases and correspond to refinement in the azimuthal direction of the 6 or 12 cell case with a single mesh layer in radial direction, and are intended for shells that are thin and should be given more resolution in azimuthal direction.
(Martin Kronbichler, 2020/04/07)
@@ -1575,7 +1575,7 @@
-
Improved: The additional roots of the HermiteLikeInterpolation with degree greater than four have been switched to the roots of the Jacobi polynomial , making the interior bubble functions orthogonal and improving the conditioning of interpolation slightly.
+
Improved: The additional roots of the HermiteLikeInterpolation with degree greater than four have been switched to the roots of the Jacobi polynomial , making the interior bubble functions orthogonal and improving the conditioning of interpolation slightly.
(Martin Kronbichler, 2019/07/12)
/usr/share/doc/packages/dealii/doxygen/deal.II/classAffineConstraints.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classAffineConstraints.html 2024-12-27 18:24:52.780763699 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAffineConstraints.html 2024-12-27 18:24:52.788763754 +0000
@@ -388,9 +388,9 @@
The algorithms used in the implementation of this class are described in some detail in the hp-paper. There is also a significant amount of documentation on how to use this class in the Constraints on degrees of freedom topic.
Description of constraints
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,aij), 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
-
+\]" src="form_1653.png"/>
is performed, where bi 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 xi, and that there might be a constant (non-homogeneous) 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 step-11 tutorial program. The name of the class stems from the fact that these constraints can be represented in matrix form as Xx = 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 step-6.
@@ -981,27 +981,27 @@
Add a constraint to this object. This function adds a constraint of the form
-
+\]" src="form_1654.png"/>
-
where is the number of the degree of freedom to be constrained and is provided by the constrained_dofs argument. The weights and indices are provided as pairs in the dependencies argument, and the inhomogeneity is provided by the last argument.
+
where is the number of the degree of freedom to be constrained and is provided by the constrained_dofs argument. The weights and indices are provided as pairs in the dependencies argument, and the inhomogeneity is provided by the last argument.
On the other hand, if (as one often wants to) you need a constraint of the kind
-
+\]" src="form_1657.png"/>
you would call this function as follows:
constraints.add_constraint (42, {}, 27.0);
If you want to constrain a degree of freedom to zero, i.e., require that
-
+\]" src="form_1658.png"/>
you would call this function as follows:
constraints.add_constraint (42, {}, 0.0);
That said, this special case can be achieved in a more obvious way by calling
constraints.constrain_dof_to_zero (42);
@@ -1026,9 +1026,9 @@
Constrain the given degree of freedom to be zero, i.e., require a constraint like
-
+\]" src="form_1659.png"/>
Calling this function is equivalent to, but more readable than, saying
constraints.add_constraint (42, {}, 0.0);
It is not an error to call this function more than once on the same degree of freedom, but it is an error to call this function on a degree of freedom that has previously been constrained to either a different value than zero, or to a linear combination of degrees of freedom via the add_constraint() function.
@@ -1161,13 +1161,13 @@
-
Add an entry to a given line. In other words, this function adds a term to the constraints for the th degree of freedom.
+
Add an entry to a given line. In other words, this function adds a term to the constraints for the th degree of freedom.
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.
Parameters
-
[in]
constrained_dof_index
The index of the degree of freedom that is being constrained.
-
[in]
column
The index of the degree of freedom being entered into the constraint for degree of freedom .
-
[in]
weight
The factor that multiplies .
+
[in]
constrained_dof_index
The index of the degree of freedom that is being constrained.
+
[in]
column
The index of the degree of freedom being entered into the constraint for degree of freedom .
+
[in]
weight
The factor that multiplies .
@@ -1228,11 +1228,11 @@
-
Set an inhomogeneity to the constraint for a degree of freedom. In other words, it adds a constant to the constraint for degree of freedom . For this to work, you need to call add_line() first for the given degree of freedom.
+
Set an inhomogeneity to the constraint for a degree of freedom. In other words, it adds a constant to the constraint for degree of freedom . For this to work, you need to call add_line() first for the given degree of freedom.
Parameters
-
[in]
constrained_dof_index
The index of the degree of freedom that is being constrained.
-
[in]
value
The right hand side value for the constraint on the degree of freedom .
+
[in]
constrained_dof_index
The index of the degree of freedom that is being constrained.
+
[in]
value
The right hand side value for the constraint on the degree of freedom .
@@ -1260,9 +1260,9 @@
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 while degree of freedom 7 is itself constrained as . Then, the resolution will be that . Note, however, that cycles in this graph of constraints are not allowed, i.e., for example may not itself be constrained, directly or indirectly, to again.
+
This function also resolves chains of constraints. For example, degree of freedom 13 may be constrained to while degree of freedom 7 is itself constrained as . Then, the resolution will be that . Note, however, that cycles in this graph of constraints are not allowed, i.e., for example may not itself be constrained, directly or indirectly, to again.
@@ -1378,7 +1378,7 @@
This function provides a "view" into a constraint object. Specifically, given a "mask" index set that describes which constraints we are interested in, it returns an AffineConstraints object that contains only those constraints that correspond to degrees of freedom that are listed in the mask, with indices shifted so that they correspond to the position within the mask. This process is the same as how IndexSet::get_view() computes the shifted indices. The function is typically used to extract from an AffineConstraints object corresponding to a DoFHandler only those constraints that correspond to a specific variable (say, to the velocity in a Stokes system) so that the resulting AffineConstraints object can be applied to a single block of a block vector of solutions; in this case, the mask would be the index set of velocity degrees of freedom, as a subset of all degrees of freedom.
This function can only work if the degrees of freedom selected by the mask are constrained only against other degrees of freedom that are listed in the mask. In the example above, this means that constraints for the selected velocity degrees of freedom are only against other velocity degrees of freedom, but not against any pressure degrees of freedom. If that is not so, an assertion will be triggered.
-
A typical case where this function is useful is as follows. Say, you have a block linear system in which you have blocks corresponding to variables (which you can think of as velocity, pressure, temperature, and chemical composition – or whatever other kind of problem you are currently considering in your own work). Let's assume we have developed a linear solver or preconditioner that first solves the coupled - system, and once that is done, solves the - system. In this case, it is often useful to set up block vectors with only two components corresponding to the and components, and later for only the - components of the solution. As part of this, you will want to apply constraints (using the distribute() function of this class) to only the 2-block vector, but for this you need to obtain an AffineConstraints object that represents only those constraints that correspond to the variables in question, and in the order in which they appear in the 2-block vector rather than in global 4-block vectors. This function allows you to extract such an object corresponding to a subset of constraints by applying a mask to the global constraints object that corresponds to the variables we're currently interested in. For the - system, we need a mask that contains all indices of degrees of freedom as well as all indices of degrees of freedom.
+
A typical case where this function is useful is as follows. Say, you have a block linear system in which you have blocks corresponding to variables (which you can think of as velocity, pressure, temperature, and chemical composition – or whatever other kind of problem you are currently considering in your own work). Let's assume we have developed a linear solver or preconditioner that first solves the coupled - system, and once that is done, solves the - system. In this case, it is often useful to set up block vectors with only two components corresponding to the and components, and later for only the - components of the solution. As part of this, you will want to apply constraints (using the distribute() function of this class) to only the 2-block vector, but for this you need to obtain an AffineConstraints object that represents only those constraints that correspond to the variables in question, and in the order in which they appear in the 2-block vector rather than in global 4-block vectors. This function allows you to extract such an object corresponding to a subset of constraints by applying a mask to the global constraints object that corresponds to the variables we're currently interested in. For the - system, we need a mask that contains all indices of degrees of freedom as well as all indices of degrees of freedom.
@@ -1718,9 +1718,9 @@
Print the constraints represented by the current object to the given stream.
For each constraint of the form
-
+\]" src="form_1668.png"/>
this function will write a sequence of lines that look like this:
42 2 : 0.5
42 14 : 0.25
@@ -2298,7 +2298,7 @@
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 non-zero, positive, and of the same order of magnitude as the other entries of the matrix. On the other hand, when solving a source problem the exact value of the diagonal element is not important, since the value of the respective degree of freedom will be overwritten by the distribute() call later on anyway.
+
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 non-zero, positive, and of the same order of magnitude as the other entries of the matrix. On the other hand, when solving a source problem the exact value of the diagonal element is not important, since the value of the respective degree of freedom will be overwritten by the distribute() call later on anyway.
Note
The procedure described above adds an unforeseeable number of artificial eigenvalues to the spectrum of the matrix. Therefore, it is recommended to use the equivalent function with two local index vectors in such a case.
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.
Note
This function in itself is thread-safe, i.e., it works properly also when several threads call it simultaneously. However, the function call is only thread-safe if the underlying global matrix allows for simultaneous access and the access is not to rows with the same global index at the same time. This needs to be made sure from the caller's site. There is no locking mechanism inside this method to prevent data races.
@@ -2340,7 +2340,7 @@
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 , it is possible to set the diagonal entry after building the matrix by a piece of code of the form
+
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 , it is possible to set the diagonal entry after building the matrix by a piece of code of the form
for (unsignedint i=0;i<matrix.m();++i)
if (constraints.is_constrained(i))
matrix.diag_element(i) = 1.;
@@ -2629,7 +2629,7 @@
-
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 , then this function will read the values of and from the given vector and set the element according to this constraints. Similarly, if the current object stores the constraint , then this function will set the 42nd element of the given vector to 208.
+
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 , then this function will read the values of and from the given vector and set the element according to this constraints. Similarly, if the current object stores the constraint , then this function will set the 42nd element of the given vector to 208.
Note
If this function is called with a parallel vector vec, then the vector must not contain ghost elements.
/usr/share/doc/packages/dealii/doxygen/deal.II/classAlgorithms_1_1ThetaTimestepping.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classAlgorithms_1_1ThetaTimestepping.html 2024-12-27 18:24:52.840764111 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAlgorithms_1_1ThetaTimestepping.html 2024-12-27 18:24:52.840764111 +0000
@@ -232,9 +232,9 @@
For fixed theta, the Crank-Nicolson 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
-
+\]" src="form_351.png"/>
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 , such that with the given matrix , it becomes
-
+
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 , such that with the given matrix , it becomes
+
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 , where is the current state vector, the mass matrix, the operator in space and is the adjusted time step size .
+
Its return value is , where is the current state vector, the mass matrix, the operator in space and is the adjusted time step size .
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 Mu-cF(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 Mu-cF(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
/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 2024-12-27 18:24:52.880764385 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAnisotropicPolynomials.html 2024-12-27 18:24:52.884764413 +0000
@@ -177,10 +177,10 @@
Detailed Description
template<int dim>
class AnisotropicPolynomials< dim >
Anisotropic tensor product of given polynomials.
-
Given one-dimensional polynomials in -direction, in -direction, and so on, this class generates polynomials of the form in -direction, in -direction, and so on, this class generates polynomials of the form . (With obvious generalization if dim is in fact only 2. If dim is in fact only 1, then the result is simply the same set of one-dimensional polynomials passed to the constructor.)
If the elements of each set of base polynomials are mutually orthogonal on the interval or , then the tensor product polynomials are orthogonal on or , respectively.
-
The resulting dim-dimensional tensor product polynomials are ordered as follows: We iterate over the coordinates running fastest, then the coordinate, etc. For example, for dim==2, the first few polynomials are thus , , , ..., , , , etc.
+
The resulting dim-dimensional tensor product polynomials are ordered as follows: We iterate over the coordinates running fastest, then the coordinate, etc. For example, for dim==2, the first few polynomials are thus , , , ..., , , , etc.
Each tensor product polynomial is a product of one-dimensional polynomials in each space direction. Compute the indices of these one-dimensional polynomials for each space direction, given the index i.
+
Each tensor product polynomial is a product of one-dimensional polynomials in each space direction. Compute the indices of these one-dimensional polynomials for each space direction, given the index i.
/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 2024-12-27 18:24:52.920764660 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classArpackSolver.html 2024-12-27 18:24:52.924764688 +0000
@@ -243,14 +243,14 @@
Detailed Description
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 , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively.
+
In this class we make use of the method applied to the generalized eigenspectrum problem , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively.
The ArpackSolver can be used in application codes with serial objects in the following way:
for the generalized eigenvalue problem , where the variable 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 , where the variable 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.
Note
Whenever you eliminate degrees of freedom using AffineConstraints, you generate spurious eigenvalues and eigenvectors. If you make sure that the diagonals of eliminated matrix rows are all equal to one, you get a single additional eigenvalue. But beware that some functions in deal.II set these diagonals to rather arbitrary (from the point of view of eigenvalue problems) values. See also step-36 for an example.
@@ -523,7 +523,7 @@
-
Solve the generalized eigensprectrum problem by calling the dsaupd and dseupd or dnaupd and dneupd functions of ARPACK.
+
Solve the generalized eigensprectrum problem by calling the 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 non-symmetric case. In the symmetric case all eigenvectors are real. In the non-symmetric 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 real-valued 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 n-th eigenvalue has a nonzero imaginary part, Arpack needs in total n+1 real-valued vectors to store real and imaginary parts of the eigenvectors.
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classArrayView.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classArrayView.html 2024-12-27 18:24:52.980765072 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classArrayView.html 2024-12-27 18:24:52.988765127 +0000
@@ -1027,7 +1027,7 @@
-
Return a reference to the th element of the range represented by the current object.
+
Return a reference to the th element of the range represented by the current object.
This function is marked as const because it does not change the view object. It may however return a reference to a non-const 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 2024-12-27 18:24:53.036765457 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classAutoDerivativeFunction.html 2024-12-27 18:24:53.040765484 +0000
@@ -365,27 +365,27 @@
where each value is the relative weight of each vertex (so the centroid is, in 2d, where each ). Since we only consider convex combinations we can rewrite this equation as
+
where each value is the relative weight of each vertex (so the centroid is, in 2d, where each ). Since we only consider convex combinations we can rewrite this equation as
Detailed Description
template<typename VectorType>
class BaseQR< VectorType >
This class and classes derived from it are meant to build and matrices one row/column at a time, i.e., by growing matrix from an empty matrix to , where is the number of added column vectors.
-
As a consequence, matrices which have the same number of rows as each vector (i.e. matrix) is stored as a collection of vectors of VectorType.
+
This class and classes derived from it are meant to build and matrices one row/column at a time, i.e., by growing matrix from an empty matrix to , where is the number of added column vectors.
+
As a consequence, matrices which have the same number of rows as each vector (i.e. matrix) is stored as a collection of vectors of VectorType.
BlockIndices represents a range of indices (such as the range of valid indices for elements of a vector) and how this one range is broken down into smaller but contiguous "blocks" (such as the velocity and pressure parts of a solution vector). In particular, it provides the ability to translate between global indices and the indices within a block. This class is used, for example, in the BlockVector, BlockSparsityPattern, and BlockMatrixBase classes.
+
BlockIndices represents a range of indices (such as the range of valid indices for elements of a vector) and how this one range is broken down into smaller but contiguous "blocks" (such as the velocity and pressure parts of a solution vector). In particular, it provides the ability to translate between global indices and the indices within a block. This class is used, for example, in the BlockVector, BlockSparsityPattern, and BlockMatrixBase classes.
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.
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:
-
+\end{eqnarray*}" src="form_1940.png"/>
-
where represent general subblocks of the matrix and, similarly, general subvectors of are given by .
+
where represent general subblocks of the matrix and, similarly, general subvectors of are given by .
This is equivalent to the following two statements:
-
+\end{eqnarray*}" src="form_1945.png"/>
-
Assuming that are both square and invertible, we could then perform one of two possible substitutions,
- are both square and invertible, we could then perform one of two possible substitutions,
+
+\end{eqnarray*}" src="form_1947.png"/>
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)
-
+\end{eqnarray*}" src="form_1948.png"/>
This leads to the result
-
+\]" src="form_1949.png"/>
-
with being the Schur complement and the modified right-hand side vector arising from the condensation step. Note that for this choice of , submatrix need not be invertible and may thus be the null matrix. Ideally should be well-conditioned.
-
So for any arbitrary vector , the Schur complement performs the following operation:
- being the Schur complement and the modified right-hand side vector arising from the condensation step. Note that for this choice of , submatrix need not be invertible and may thus be the null matrix. Ideally should be well-conditioned.
+
So for any arbitrary vector , the Schur complement performs the following operation:
+
+\]" src="form_1956.png"/>
A typical set of steps needed the solve a linear system (1),(2) would be:
Define iterative inverse matrix such that (6) holds. It is necessary to use a solver with a preconditioner to compute the approximate inverse operation of since we never compute directly, but rather the result of its operation. To achieve this, one may again use the inverse_operator() in conjunction with the Schur complement that we've just constructed. Observe that the both and its preconditioner operate over the same space as .
Define iterative inverse matrix such that (6) holds. It is necessary to use a solver with a preconditioner to compute the approximate inverse operation of since we never compute directly, but rather the result of its operation. To achieve this, one may again use the inverse_operator() in conjunction with the Schur complement that we've just constructed. Observe that the both and its preconditioner operate over the same space as .
In the above example, the preconditioner for was defined as the preconditioner for , which is valid since they operate on the same space. However, if and are too dissimilar, then this may lead to a large number of solver iterations as is not a good approximation for .
-
A better preconditioner in such a case would be one that provides a more representative approximation for . One approach is shown in step-22, where is the null matrix and the preconditioner for is derived from the mass matrix over this space.
-
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for wherein expensive operation, namely , is approximated. Thereafter we construct the approximate inverse operator which is then used as the preconditioner for computing .
// Construction of approximate inverse of Schur complement
+
In the above example, the preconditioner for was defined as the preconditioner for , which is valid since they operate on the same space. However, if and are too dissimilar, then this may lead to a large number of solver iterations as is not a good approximation for .
+
A better preconditioner in such a case would be one that provides a more representative approximation for . One approach is shown in step-22, where is the null matrix and the preconditioner for is derived from the mass matrix over this space.
+
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for wherein expensive operation, namely , is approximated. Thereafter we construct the approximate inverse operator which is then used as the preconditioner for computing .
// Construction of approximate inverse of Schur complement
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 which acts only as the preconditioner for . Furthermore, the preconditioner to , which in this example is , should ideally be computationally inexpensive.
+
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 which acts only as the preconditioner for . Furthermore, the preconditioner to , which in this example is , should ideally be computationally inexpensive.
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 test-suite, such as tests/lac/schur_complement_01.cc. The solution of a multi-component problem (namely step-22) using the schur_complement can be found in tests/lac/schur_complement_03.cc.
/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 2024-12-27 18:24:53.280767133 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockMatrixBase.html 2024-12-27 18:24:53.284767160 +0000
@@ -1309,7 +1309,7 @@
const BlockVectorType &
src&#href_anchor"memdoc">
-
Adding Matrix-vector multiplication. Add on with being this matrix.
+
Adding Matrix-vector multiplication. Add on with being this matrix.
@@ -1757,7 +1757,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Due to problems with deriving template arguments between the block and non-block 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.
@@ -1881,7 +1881,7 @@
-
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
+
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrix.html 2024-12-27 18:24:53.356767654 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrix.html 2024-12-27 18:24:53.360767682 +0000
@@ -954,7 +954,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Adding Matrix-vector multiplication. Add on with being this matrix.
+
Adding Matrix-vector multiplication. Add on with being this matrix.
@@ -2627,7 +2627,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Due to problems with deriving template arguments between the block and non-block 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.
@@ -2735,7 +2735,7 @@
-
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
+
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrixEZ.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrixEZ.html 2024-12-27 18:24:53.408768012 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockSparseMatrixEZ.html 2024-12-27 18:24:53.412768039 +0000
@@ -767,7 +767,7 @@
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2237,7 +2237,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVectorBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVectorBase.html 2024-12-27 18:24:53.544768945 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBlockVectorBase.html 2024-12-27 18:24:53.552769000 +0000
@@ -1257,7 +1257,7 @@
-
: scalar product.
+
: scalar product.
@@ -1277,7 +1277,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
@@ -1317,7 +1317,7 @@
-
Return the -norm of the vector, i.e. the sum of the absolute values.
+
Return the -norm of the vector, i.e. the sum of the absolute values.
@@ -1337,7 +1337,7 @@
-
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
+
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
@@ -1357,7 +1357,7 @@
-
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
+
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -1587,7 +1587,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classBoundingBox.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classBoundingBox.html 2024-12-27 18:24:53.596769302 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classBoundingBox.html 2024-12-27 18:24:53.600769330 +0000
@@ -179,11 +179,11 @@
&#href_anchor"details" id="details">
Detailed Description
template<int spacedim, typename Number = double>
class BoundingBox< spacedim, Number >
A class that represents a box of arbitrary dimension spacedim and with sides parallel to the coordinate axes, that is, a region
-
+\]" src="form_362.png"/>
-
where and denote the two vertices (bottom left and top right) which are used to represent the box. The quantities and denote the "lower" and "upper" bounds of values that are within the box for each coordinate direction .
+
where and denote the two vertices (bottom left and top right) which are used to represent the box. The quantities and denote the "lower" and "upper" bounds of values that are within the box for each coordinate direction .
Geometrically, a bounding box is thus:
1d: a segment (represented by its vertices in the proper order)
2d: a rectangle (represented by the vertices V at bottom left, top right)
.--------V
@@ -199,7 +199,7 @@
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 3d-coordinate into a 2d-coordinate as or as . This class uses the second convention, corresponding to the coordinates being ordered cyclicly To be precise, if we take a cross section:
+
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 3d-coordinate into a 2d-coordinate as or as . This class uses the second convention, corresponding to the coordinates being ordered cyclicly To be precise, if we take a cross section:
Orthogonal to
Cross section coordinates ordered as
@@ -744,7 +744,7 @@
-
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.
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g., in the finite context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g., in the finite context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
Return the -norm of the matrix, that is , (max. sum of rows). This is the natural norm that is compatible to the -norm of vectors, i.e., -norm of the matrix, that is , (max. sum of rows). This is the natural norm that is compatible to the -norm of vectors, i.e., .
/usr/share/doc/packages/dealii/doxygen/deal.II/classChartManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classChartManifold.html 2024-12-27 18:24:53.692769962 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classChartManifold.html 2024-12-27 18:24:53.696769989 +0000
@@ -206,37 +206,37 @@
Detailed Description
template<int dim, int spacedim = dim, int chartdim = dim>
class ChartManifold< dim, spacedim, chartdim >
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 step-53.
-
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 can be represented by a map
-
+
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 can be represented by a map
+
(the push_forward() function) and that admits the inverse transformation
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.
Providing function gradients
-
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 ), one needs to also have access to the gradient of the push-forward function . The gradient is the matrix , where we take the derivative with regard to the chartdim reference coordinates on the flat Euclidean space in which is located. In other words, at a point , is a matrix of size 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 ), one needs to also have access to the gradient of the push-forward function . The gradient is the matrix , where we take the derivative with regard to the chartdim reference coordinates on the flat Euclidean space in which is located. In other words, at a point , is a matrix of size spacedim times chartdim.
Only the ChartManifold::get_tangent_vector() function uses the gradient of the push-forward, 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.
A note on the template arguments
The dimension arguments chartdim, dim and spacedim must satisfy the following relationships:
dim <= spacedim
chartdim <= spacedim
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
-
+ \]" src="form_1502.png"/>
in which case chartdim is 1. On the other hand, there is no reason why one can't describe this as a mapping
-
+ \]" src="form_1503.png"/>
-
in such a way that the line happens to be mapped onto the edge in question. Here, chartdim is 3. This may seem cumbersome but satisfies the requirements of an invertible function just fine as long as it is possible to get from the edge to the pull-back space and then back again. Finally, given that we are dealing with a 2d triangulation in 3d, one will often have a mapping from, say, the 2d unit square or unit disk to the domain in 3d space, and the edge in question may simply be the mapped edge of the unit domain in 2d space. In this case, chartdim is 2.
+
in such a way that the line happens to be mapped onto the edge in question. Here, chartdim is 3. This may seem cumbersome but satisfies the requirements of an invertible function just fine as long as it is possible to get from the edge to the pull-back space and then back again. Finally, given that we are dealing with a 2d triangulation in 3d, one will often have a mapping from, say, the 2d unit square or unit disk to the domain in 3d space, and the edge in question may simply be the mapped edge of the unit domain in 2d space. In this case, chartdim is 2.
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -595,24 +595,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparseMatrix.html 2024-12-27 18:24:53.756770401 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparseMatrix.html 2024-12-27 18:24:53.764770456 +0000
@@ -1049,7 +1049,7 @@
-
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().
@@ -1380,7 +1380,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation, and for 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 complex-valued, but not mixed, for this function to make sense.
@@ -1454,8 +1454,8 @@
-
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)
@@ -1475,8 +1475,8 @@
-
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann : Numerische Mathematik)
@@ -2175,7 +2175,7 @@
-
Return the location of entry within the val array.
+
Return the location of entry within the val array.
/usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparsityPattern.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparsityPattern.html 2024-12-27 18:24:53.820770841 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classChunkSparsityPattern.html 2024-12-27 18:24:53.824770869 +0000
@@ -1136,7 +1136,7 @@
-
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
+
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
/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 2024-12-27 18:24:53.868771171 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCompositionManifold.html 2024-12-27 18:24:53.876771226 +0000
@@ -579,24 +579,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/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 2024-12-27 18:24:53.928771583 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classCylindricalManifold.html 2024-12-27 18:24:53.936771638 +0000
@@ -414,7 +414,7 @@
-
Compute the cylindrical coordinates for the given space point where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
+
Compute the cylindrical coordinates for the given space point where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
Compute the Cartesian coordinates for a chart point given in cylindrical coordinates , where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
+
Compute the Cartesian coordinates for a chart point given in cylindrical coordinates , where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
Compute the derivatives of the mapping from cylindrical coordinates to cartesian coordinates where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
+
Compute the derivatives of the mapping from cylindrical coordinates to cartesian coordinates where denotes the distance from the axis, the angle between the given point and the computed normal direction, and the axial position.
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -756,24 +756,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessor.html 2024-12-27 18:24:53.968771857 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessor.html 2024-12-27 18:24:53.972771885 +0000
@@ -196,7 +196,7 @@
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 complex-valued.
Implementations of the DataPostprocessor::evaluate_vector_field() in derived classes must understand how the solution values are arranged in the DataPostprocessorInputs::Vector objects they receive as input. The rule here is: If the finite element has vector components (including the case , i.e., a scalar element), then the inputs for complex-valued solution vectors will have components. These first contain the values (or gradients, or Hessians) of the real parts of all solution components, and then the values (or gradients, or Hessians) of the imaginary parts of all solution components.
+
Implementations of the DataPostprocessor::evaluate_vector_field() in derived classes must understand how the solution values are arranged in the DataPostprocessorInputs::Vector objects they receive as input. The rule here is: If the finite element has vector components (including the case , i.e., a scalar element), then the inputs for complex-valued solution vectors will have components. These first contain the values (or gradients, or Hessians) of the real parts of all solution components, and then the values (or gradients, or Hessians) of the imaginary parts of all solution components.
step-58 provides an example of how this class (or, rather, the derived DataPostprocessorScalar class) is used in a complex-valued 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 2024-12-27 18:24:54.012772160 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorTensor.html 2024-12-27 18:24:54.012772160 +0000
@@ -269,7 +269,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/computer-codes/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 . This is easily facilitated with the following minor modification:
template <int dim>
+
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 . This is easily facilitated with the following minor modification:
/usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorVector.html 2024-12-27 18:24:54.052772434 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDataPostprocessorVector.html 2024-12-27 18:24:54.060772489 +0000
@@ -260,7 +260,7 @@
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 of the solution – corresponds to the temperature gradient if one interpreted step-6 as solving a steady-state heat transfer problem. It is very small in the central part of the domain because in step-6 we are solving an equation that has a coefficient that is large in the central part and small on the outside. This can be thought as a material that conducts heat well, and consequently the temperature gradient is small. On the other hand, the "heat flux" corresponds to the quantity . For the solution of that equation, the flux should be continuous across the interface. This is easily verified by the following modification of the postprocessor:
template <int dim>
+
The output above – namely, the gradient of the solution – corresponds to the temperature gradient if one interpreted step-6 as solving a steady-state heat transfer problem. It is very small in the central part of the domain because in step-6 we are solving an equation that has a coefficient that is large in the central part and small on the outside. This can be thought as a material that conducts heat well, and consequently the temperature gradient is small. On the other hand, the "heat flux" corresponds to the quantity . For the solution of that equation, the flux should be continuous across the interface. This is easily verified by the following modification of the postprocessor:
/usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1SecondDerivative.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1SecondDerivative.html 2024-12-27 18:24:54.084772654 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1SecondDerivative.html 2024-12-27 18:24:54.092772709 +0000
@@ -248,7 +248,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 norm of vectors. It is also the largest value of the curvature of the solution.
+
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 norm of vectors. It is also the largest value of the curvature of the solution.
/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 2024-12-27 18:24:54.112772846 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeApproximation_1_1internal_1_1ThirdDerivative.html 2024-12-27 18:24:54.120772901 +0000
@@ -243,7 +243,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 norm of vectors. It is also the largest value of the curvature of the solution.
+
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 norm of vectors. It is also the largest value of the curvature of the solution.
/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 2024-12-27 18:24:54.156773148 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDerivativeForm.html 2024-12-27 18:24:54.156773148 +0000
@@ -497,7 +497,7 @@
-
Compute the volume element associated with the jacobian of the transformation . That is to say if is square, it computes , in case DF is not square returns .
+
Compute the volume element associated with the jacobian of the transformation . That is to say if is square, it computes , in case DF is not square returns .
@@ -517,7 +517,7 @@
-
Assuming that the current object stores the Jacobian of a mapping , then the current function computes the covariant form of the derivative, namely , where . If , then the current function computes the covariant form of the derivative, namely , where . If is a square matrix (i.e., ), then this function simplifies to computing .
@@ -634,7 +634,7 @@
-
One of the uses of DerivativeForm is to apply it as a linear transformation. This function returns , which approximates the change in when is changed by the amount
+
One of the uses of DerivativeForm is to apply it as a linear transformation. This function returns , which approximates the change in when is changed by the amount
-
Similar to the previous apply_transformation(). In matrix notation, it computes . Moreover, the result of this operation can be interpreted as a metric tensor in which corresponds to the Euclidean metric tensor in . For every pair of vectors , we have:
+
Similar to the previous apply_transformation(). In matrix notation, it computes . Moreover, the result of this operation can be interpreted as a metric tensor in which corresponds to the Euclidean metric tensor in . For every pair of vectors , we have:
-
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 with respect to all independent variables, i.e.
+
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 with respect to all independent variables, i.e.
-
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 with respect to all independent variables, i.e.
+
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 with respect to all independent variables, i.e.
and all quantities of the simulation (displacements, strains, temperatures, etc.) are up-to-date for . In this stage, current time refers to , next time refers to , previous time refers to . The other useful notation quantities are the next time step size and previous time step size . In this stage, it is a perfect occasion to generate text output using print commands within the user's code. Additionally, post-processed outputs can be prepared here, which can then later be viewed by visualization programs such as 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 to . All of the variables need to be updated one by one, the step number is incremented, the time is incremented by , and time-integration algorithms are used to update the other simulation quantities. In the middle of this stage, some variables have been updated to but other variables still represent their value at . Thus, we call this the inconsistent stage, requiring that no post-processing output related to the state variables take place within it. The state variables, namely those related to time, the solution field and any internal variables, are not synchronized and then get updated one by one. In general, the order of updating variables is arbitrary, but some care should be taken if there are interdependencies between them. For example, if some variable such as depends on the calculation of another variable such as , then must be updated before can be updated.
+
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 to . All of the variables need to be updated one by one, the step number is incremented, the time is incremented by , and time-integration algorithms are used to update the other simulation quantities. In the middle of this stage, some variables have been updated to but other variables still represent their value at . Thus, we call this the inconsistent stage, requiring that no post-processing output related to the state variables take place within it. The state variables, namely those related to time, the solution field and any internal variables, are not synchronized and then get updated one by one. In general, the order of updating variables is arbitrary, but some care should be taken if there are interdependencies between them. For example, if some variable such as depends on the calculation of another variable such as , then must be updated before can be updated.
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:
Time is incremented before the rest of the updates. In this case, even though time is incremented to , not all variables are updated yet. During this update phase, equals the previous time step size. Previous means that it is referring to the of the 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.
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 whose elements are finite element functions defined on each cell by a FiniteElement object. This class satisfies the MeshType concept requirements.
+class DoFHandler< dim, spacedim >
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 whose elements are finite element functions defined on each cell by a FiniteElement object. This class satisfies the MeshType concept requirements.
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.
@@ -439,7 +439,7 @@
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 re-loading data from the serialization archive.
hp-adaptive finite element methods
-
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 and elements meeting at a common face), then one needs to compute constraints to ensure that the resulting finite element space on the mesh remains conforming.
+
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 and elements meeting at a common face), then one needs to compute constraints to ensure that the resulting finite element space on the mesh remains conforming.
The whole process of working with objects of this type is explained in step-27. Many of the algorithms this class implements are described in the hp-paper.
Active FE indices and their behavior under mesh refinement
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.
@@ -988,7 +988,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 , the process of distributing degrees of freedom makes sure that there is a basis for this space and that the shape functions of this basis are enumerated in an indexable, predictable way.
+
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 process of distributing degrees of freedom makes sure that there is a basis for this space and that the shape functions of this basis are enumerated in an indexable, predictable way.
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 step-2 tutorial program.
Note
This function makes a copy of the finite element given as argument, and stores it as a member variable, similarly to the above function set_fe().
/usr/share/doc/packages/dealii/doxygen/deal.II/classDynamicSparsityPattern.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classDynamicSparsityPattern.html 2024-12-27 18:24:54.380774687 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classDynamicSparsityPattern.html 2024-12-27 18:24:54.388774742 +0000
@@ -1119,7 +1119,7 @@
-
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix.
+
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix.
/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 2024-12-27 18:24:54.428775017 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenInverse.html 2024-12-27 18:24:54.432775044 +0000
@@ -204,7 +204,7 @@
template<typename VectorType = Vector<double>>
class EigenInverse< VectorType >
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 is computed. Since this might not converge to zero for non-symmetric matrices with non-trivial Jordan blocks, it can be replaced by checking the difference of successive eigenvalues. Use AdditionalData::use_residual for switching this option.
+
There are two choices for the stopping criterion: by default, the norm of the residual is computed. Since this might not converge to zero for non-symmetric matrices with non-trivial Jordan blocks, it can be replaced by checking the difference of successive eigenvalues. Use AdditionalData::use_residual for switching this option.
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.
/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 2024-12-27 18:24:54.460775236 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEigenPower.html 2024-12-27 18:24:54.468775291 +0000
@@ -203,7 +203,7 @@
Detailed Description
template<typename VectorType = Vector<double>>
class EigenPower< VectorType >
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 with dominant absolute value, the iteration vectors will become aligned to its eigenspace and .
+
This method determines the largest eigenvalue of a matrix by applying increasing powers of this matrix to a vector. If there is an eigenvalue with dominant absolute value, the iteration vectors will become aligned to its eigenspace and .
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 2024-12-27 18:24:54.512775593 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classEllipticalManifold.html 2024-12-27 18:24:54.512775593 +0000
@@ -233,15 +233,15 @@
template<int dim, int spacedim = dim>
class EllipticalManifold< dim, spacedim >
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
-
+\]" src="form_1530.png"/>
-
in which are coordinates of the center of the cartesian system.
-
The current implementation uses coordinates , instead of , and fixes according to a given eccentricity. Therefore, this choice of coordinates generates an elliptical manifold characterized by a constant eccentricity: , with .
+
in which are coordinates of the center of the cartesian system.
+
The current implementation uses coordinates , instead of , and fixes according to a given eccentricity. Therefore, this choice of coordinates generates an elliptical manifold characterized by a constant eccentricity: , with .
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:
@@ -352,7 +352,7 @@
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 .
@@ -489,7 +489,7 @@
-
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -614,7 +614,7 @@
Return the periodicity associated with the submanifold.
-
For and , the first coordinate is non-periodic, while the second coordinate has a periodicity of .
+
For and , the first coordinate is non-periodic, while the second coordinate has a periodicity of .
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -862,24 +862,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFECouplingValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFECouplingValues.html 2024-12-27 18:24:54.556775896 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFECouplingValues.html 2024-12-27 18:24:54.560775923 +0000
@@ -178,44 +178,44 @@
class FECouplingValues< dim1, dim2, spacedim >
FECouplingValues is a class that facilitates the integration of finite element data between two different finite element objects, possibly living on different grids, and with possibly different topological dimensions (i.e., cells, faces, edges, and any combination thereof).
This class provides a way to simplify the implementation of the following abstract operation:
-
+\]" src="form_1096.png"/>
for three different types of Kernels :
-
is a non-singular Kernel function, for example, it is a function of positive powers of the distance between the quadrature points ;
-
is a singular Kernel function, for example, it is a function of negative powers of the distance between the quadrature points ;
-
is a Dirac delta distribution , such that the integral above is actually a single integral over the intersection of the two sets and .
+
is a non-singular Kernel function, for example, it is a function of positive powers of the distance between the quadrature points ;
+
is a singular Kernel function, for example, it is a function of negative powers of the distance between the quadrature points ;
+
is a Dirac delta distribution , such that the integral above is actually a single integral over the intersection of the two sets and .
For the first case, one may think that the only natural way to proceed is to compute the double integral by simply nesting two loops:
-
+\]" src="form_1100.png"/>
-
where and are the quadrature points in and respectively, and and are the corresponding quadrature weights.
-
This, however is not the only way to proceed. In fact, such an integral can be rewritten as a single loop over corresponding elements of two arrays of points with the same length that can be thought of as a single quadrature rule on the set . For singular kernels, for example, this is often the only way to proceed, since the quadrature formula on is usually not written as a tensor product quadrature formula, and one needs to build a custom quadrature formula for this purpose.
+
where and are the quadrature points in and respectively, and and are the corresponding quadrature weights.
+
This, however is not the only way to proceed. In fact, such an integral can be rewritten as a single loop over corresponding elements of two arrays of points with the same length that can be thought of as a single quadrature rule on the set . For singular kernels, for example, this is often the only way to proceed, since the quadrature formula on is usually not written as a tensor product quadrature formula, and one needs to build a custom quadrature formula for this purpose.
This class allows one to treat the three cases above in the same way, and to approximate the integral as follows:
-
+\]" src="form_1107.png"/>
-
Since the triple of objects is usually provided by a class derived from the FEValuesBase class, this is the type that the class needs at construction time. and can be two arbitrary cells, faces, or edges belonging to possibly different meshes (or to meshes with different topological dimensions), and are basis functions defined on and , respectively.
-
The case of the Dirac distribution is when and correspond to the common face of two neighboring cells. In this case, this class provides a functionality which is similar to the FEInterfaceValues class, and gives you a way to access values of basis functions on the neighboring cells, as well as their gradients and Hessians, in a unified fashion, on the face.
+
Since the triple of objects is usually provided by a class derived from the FEValuesBase class, this is the type that the class needs at construction time. and can be two arbitrary cells, faces, or edges belonging to possibly different meshes (or to meshes with different topological dimensions), and are basis functions defined on and , respectively.
+
The case of the Dirac distribution is when and correspond to the common face of two neighboring cells. In this case, this class provides a functionality which is similar to the FEInterfaceValues class, and gives you a way to access values of basis functions on the neighboring cells, as well as their gradients and Hessians, in a unified fashion, on the face.
Similarly, this class can be used to couple bulk and surface meshes across the faces of the bulk mesh. In this case, the two FEValuesBase objects will have different topological dimension (i.e., one will be a cell in a co-dimension one triangulation, and the other a face of a bulk grid with co-dimension zero), and the QuadratureCouplingType argument is usually chosen to be QuadratureCouplingType::reorder, since the quadrature points of the two different FEValuesBase objects are not necessarily generated with the same ordering.
The type of integral to compute is controlled by the QuadratureCouplingType argument (see the documentation of that enum class for more details), while the type degrees of freedom coupling is controlled by the DoFCouplingType argument (see the documentation of that enum class for more details).
As an example usage of this class, consider the a bilinear form of the form:
-
+\]" src="form_1111.png"/>
-
where the finite dimensional space has two scalar components. We indicate with and the trial functions, and with and the corresponding test functions. and are coupling kernels: such a formulation is used, for example, to write the bilinear forms of Galerkin boundary element methods.
+
where the finite dimensional space has two scalar components. We indicate with and the trial functions, and with and the corresponding test functions. and are coupling kernels: such a formulation is used, for example, to write the bilinear forms of Galerkin boundary element methods.
The corresponding implementation would look like the following:
... // double loop over cells that yields cell_1 and cell_2
@@ -338,9 +338,9 @@
Construct the FECouplingValues with two arbitrary FEValuesBase objects. This class assumes that the FEValuesBase objects that are given at construction time are initialized and ready to use (i.e., that you have called the reinit() function on them before calling this constructor).
Notice that the actual renumbering of the degrees of freedom and quadrature points is done at construction time, or upon calling the reinit() function. If you change the underlying FEValuesBase objects after construction, you must call the reinit() function to update the renumbering. This may or may not be necessary, depending on the type of coupling that you are using.
This really depends on the application and on the specific type of coupling. For example, for volume/volume coupling, i.e., for operators with non-local and non-singular kernels of type
-
+\]" src="form_1116.png"/>
you may initialize FECouplingValues once, and just reinit the underlying FEValuesBase objects on different cells K and T, without the need to recompute the coupling (i.e., the numbering is always the same, and nothing differs from what happened in the first call).
For cell/surface coupling, the same cell may couple with different faces, so the renumbering must be really computed from scratch for each pair of FEValuesBase objects, so reinitializing the underlying cells and faces will make the renumbering itself invalid, and FECouplingValues must be reinitialized (o constructed from scratch) after calling fe_values_1.reinit(K) and fe_values_1.reinit(T).
@@ -390,9 +390,9 @@
Reinitialize the FECouplingValues with two arbitrary FEValuesBase objects. The FEValuesBase objects must be initialized and ready to use, i.e., you must have called the reinit() function on them before calling this method.
This method computes the actual renumbering of the degrees of freedom and quadrature points. If you change the underlying FEValuesBase objects after calling this method, you may need to call the reinit() function to update the renumbering. This may or may not be necessary, depending on the type of coupling that you are using.
This really depends on the application and on the specific type of coupling. For example, for volume/volume coupling, i.e., for operators with non-local and non-singular kernels of type
-
+\]" src="form_1116.png"/>
you may initialize FECouplingValues once, and just reinit the underlying FEValuesBase objects on different cells K and T, without the need to recompute the coupling (i.e., the numbering is always the same, and nothing differs from what happened in the first call).
For cell/surface coupling, the same cell may couple with different faces, so the renumbering must be really computed from scratch for each pair of FEValuesBase objects, so reinitializing the underlying cells and faces will make the renumbering itself invalid, and FECouplingValues must be reinitialized (o constructed from scratch) after calling fe_values_1.reinit(K) and fe_values_1.reinit(T).
@@ -489,8 +489,8 @@
-
Return the two quadrature points in real space at the given quadrature point index, corresponding to a quadrature point in the set .
+
Return the two quadrature points in real space at the given quadrature point index, corresponding to a quadrature point in the set .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_quadrature_points 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluation.html 2024-12-27 18:24:54.668776665 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluation.html 2024-12-27 18:24:54.676776720 +0000
@@ -463,7 +463,7 @@
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 , this is done by the following cell-wise integration:
+
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 , this is done by the following cell-wise integration:
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to evaluate(EvaluationFlags::gradients) the direction normal to the face: .
+
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to 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.
@@ -2114,7 +2114,7 @@
-
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
+
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
Note
Only available for the vector-valued case (n_components == dim) in 2 and 3 dimensions.
@@ -2486,8 +2486,8 @@
-
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
+
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationBase.html 2024-12-27 18:24:54.772777379 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationBase.html 2024-12-27 18:24:54.776777406 +0000
@@ -1131,8 +1131,8 @@
-
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to evaluate(EvaluationFlags::gradients) the direction normal to the face: .
+
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to 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.
@@ -1402,7 +1402,7 @@
-
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
+
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
Note
Only available for the vector-valued case (n_components == dim) in 2 and 3 dimensions.
@@ -1801,8 +1801,8 @@
-
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
+
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationData.html 2024-12-27 18:24:54.844777873 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEEvaluationData.html 2024-12-27 18:24:54.852777928 +0000
@@ -785,8 +785,8 @@
-
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
+
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceEvaluation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceEvaluation.html 2024-12-27 18:24:54.956778642 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceEvaluation.html 2024-12-27 18:24:54.960778669 +0000
@@ -1717,8 +1717,8 @@
-
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to evaluate(EvaluationFlags::gradients) the direction normal to the face: .
+
Return the derivative of a finite element function interpolated to the quadrature point with index q_point after a call to 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.
@@ -2078,7 +2078,7 @@
-
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
+
Return the curl of the vector field, interpolated to the quadrature point index after calling evaluate(EvaluationFlags::gradients).
Note
Only available for the vector-valued case (n_components == dim) in 2 and 3 dimensions.
@@ -2472,8 +2472,8 @@
-
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
+
Return the inverse and transposed version of the Jacobian of the mapping between the unit to the real cell defined as . The entry of the returned tensor contains , i.e., columns refer to reference space coordinates and rows to real cell coordinates. Thus, the returned tensor represents a covariant transformation, which is used in the FEEvaluationBase::get_gradient() function to transform the unit cell gradients to gradients on the real cell by a multiplication .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValues.html 2024-12-27 18:24:55.136779879 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValues.html 2024-12-27 18:24:55.144779934 +0000
@@ -963,7 +963,7 @@
If the shape function is vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -1004,7 +1004,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -1043,7 +1043,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -1251,11 +1251,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
@@ -1831,7 +1831,7 @@
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2607,7 +2607,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2665,8 +2665,8 @@
-
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, pushed forward to the real cell coordinates, 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, pushed forward to the real cell coordinates, i.e. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_jacobian_pushed_forward_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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValuesBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValuesBase.html 2024-12-27 18:24:55.244780620 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEFaceValuesBase.html 2024-12-27 18:24:55.248780648 +0000
@@ -667,7 +667,7 @@
If the shape function is vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -706,7 +706,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -743,7 +743,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -937,11 +937,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
@@ -1461,7 +1461,7 @@
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2179,7 +2179,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2233,8 +2233,8 @@
-
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, pushed forward to the real cell coordinates, 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, pushed forward to the real cell coordinates, i.e. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_jacobian_pushed_forward_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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceValues.html 2024-12-27 18:24:55.320781142 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceValues.html 2024-12-27 18:24:55.324781170 +0000
@@ -496,9 +496,9 @@
If the 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.
If one of these arguments is left at its default value, then the function will need to choose a quadrature and/or mapping that is appropriate for the two finite element spaces used on the two cells adjacent to the current interface. As the first choice, if the quadrature or mapping collection we are considering has only one element, then that is clearly the one that should be used.
If the quadrature or mapping collection have multiple elements, then we need to dig further. For quadrature objects, we can compare whether the two quadrature objects that correspond to the 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.
-
If this has still not helped, we try to find out which of the two finite element spaces on the two adjacent cells is "larger" (say, if you had used and elements on the two adjacent cells, then the element is the larger one); the determination of which space is "larger" is made using the hp::FECollection::find_dominated_fe() function, which is not necessarily intended for this kind of query, but yields a result that serves just fine for our purposes here. We then operate on the assumption that the quadrature object associated with the "larger" of the two spaces is the appropriate one to use for the face that separates these two spaces.
-
If this function returns that one of the two elements in question is dominated by the other, then presumably it is "larger" one and we take the quadrature formula and mapping that corresponds to this "larger" element is. For example, for the element mentioned above, one would generally use a QGauss(3) quadrature formula, whereas for the element, one would use QGauss(5). To integrate jump and average terms on the interface between cells using these two elements, QGauss(5) is appropriate. Because, typically, people will order elements in the hp::FECollection in the same order as the quadrature and mapping objects in hp::QCollection and hp::MappingCollection, this function will use the index of the "larger" element in the hp::FECollection to also index into the hp::QCollection and hp::MappingCollection to retrieve quadrature and mapping objects appropriate for the current face.
-
There are cases where neither element dominates the other. For example, if one uses and elements on neighboring cells, neither of the two spaces dominates the other – or, in the context of the current function, neither space is "larger" than the other. In that case, there is no way for the current function to determine quadrature and mapping objects associated with the two elements are the appropriate ones. If that happens, you will get an error – and the only way to avoid the error is to explicitly specify for these interfaces which quadrature and mapping objects you want to use, by providing non-default values for the q_index and mapping_index arguments to this function.
+
If this has still not helped, we try to find out which of the two finite element spaces on the two adjacent cells is "larger" (say, if you had used and elements on the two adjacent cells, then the element is the larger one); the determination of which space is "larger" is made using the hp::FECollection::find_dominated_fe() function, which is not necessarily intended for this kind of query, but yields a result that serves just fine for our purposes here. We then operate on the assumption that the quadrature object associated with the "larger" of the two spaces is the appropriate one to use for the face that separates these two spaces.
+
If this function returns that one of the two elements in question is dominated by the other, then presumably it is "larger" one and we take the quadrature formula and mapping that corresponds to this "larger" element is. For example, for the element mentioned above, one would generally use a QGauss(3) quadrature formula, whereas for the element, one would use QGauss(5). To integrate jump and average terms on the interface between cells using these two elements, QGauss(5) is appropriate. Because, typically, people will order elements in the hp::FECollection in the same order as the quadrature and mapping objects in hp::QCollection and hp::MappingCollection, this function will use the index of the "larger" element in the hp::FECollection to also index into the hp::QCollection and hp::MappingCollection to retrieve quadrature and mapping objects appropriate for the current face.
+
There are cases where neither element dominates the other. For example, if one uses and elements on neighboring cells, neither of the two spaces dominates the other – or, in the context of the current function, neither space is "larger" than the other. In that case, there is no way for the current function to determine quadrature and mapping objects associated with the two elements are the appropriate ones. If that happens, you will get an error – and the only way to avoid the error is to explicitly specify for these interfaces which quadrature and mapping objects you want to use, by providing non-default values for the q_index and mapping_index arguments to this function.
@@ -834,7 +834,7 @@
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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the surface element in the integral that we implement here by quadrature.
Return the jump on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
Return the jump on the interface for the shape function 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 , that is "the value here (minus zero)".
+
If this is a boundary face (at_boundary() returns true), then , that is "the value here (minus zero)".
Note
The name of the function is supposed to be read as "the jump
(singular) in the values (plural: one or two possible values)
of the shape function (singular)".
Return the jump in the gradient on the interface for the shape function 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 on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the jump
(singular) in the gradients (plural: one or two possible gradients)
of the shape function (singular)".
Return the jump in the Hessian on the interface for the shape function 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 on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the jump
(singular) in the Hessians (plural: one or two possible values
for the derivative) of the shape function (singular)".
Return the jump in the third derivative on the interface for the shape function 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 on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the jump
(singular) in the third derivatives (plural: one or two possible values
for the derivative) of the shape function (singular)".
Return the average on the interface for the shape function 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 on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the average
(singular) of the values (plural: one or two possible values)
of the shape function (singular)".
Return the average of the gradient on the interface for the shape function 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 on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the average
(singular) of the gradients (plural: one or two possible values
for the gradient) of the shape function (singular)".
Return the average of the Hessian on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
-
If this is a boundary face (at_boundary() returns true), then .
+u_{\text{cell1}}$" src="form_1170.png"/> on the interface for the shape function interface_dof_index at the quadrature point q_point of component component.
+
If this is a boundary face (at_boundary() returns true), then .
Note
The name of the function is supposed to be read as "the average
(singular) of the Hessians (plural: one or two possible values
for the second derivatives) of the shape function (singular)".
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceViews_1_1Scalar.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceViews_1_1Scalar.html 2024-12-27 18:24:55.380781554 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEInterfaceViews_1_1Scalar.html 2024-12-27 18:24:55.372781499 +0000
@@ -475,7 +475,7 @@
Return the jump on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
+
Return the jump on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the values (plural: one or two possible values) of
the shape function (singular)".
Return the jump of the gradient on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
+
Return the jump of the gradient on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the gradients (plural: one or two possible gradients)
of the shape function (singular)".
Return the jump in the gradient on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+
Return the jump in the gradient on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the Hessians (plural: one or two possible values
for the second derivative) of the shape function (singular)".
Return the jump in the third derivative on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+
Return the jump in the third derivative on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the third derivatives (plural: one or two possible values
for the third derivative) of the shape function (singular)".
Return the average value on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
+
Return the average value on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the average
(singular) of the values (plural: one or two possible values) of
the shape function (singular)".
Return the average of the gradient on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
+
Return the average of the gradient on the interface for the shape function interface_dof_index in the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the average
(singular) of the gradients (plural: one or two possible values of
the derivative) of the shape function (singular)".
Return the average of the Hessian on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+u_{\text{cell1}}$" src="form_1170.png"/> on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the average
(singular) in the Hessians (plural: one or two possible values of
the second derivative) of the shape function (singular)".
@@ -659,7 +659,7 @@
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -948,7 +948,7 @@
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the jump vector on the interface for the shape function interface_dof_index in the quadrature point q_point.
+
Return the jump vector on the interface for the shape function interface_dof_index in the quadrature point q_point.
Note
The name of the function is supposed to be read as "the jump
(singular) in the values (plural: one or two possible values) of
the shape function (singular)".
Return the jump of the gradient (a tensor of rank 2) on the interface for the shape function interface_dof_index in the quadrature point q_point.
+
Return the jump of the gradient (a tensor of rank 2) on the interface for the shape function interface_dof_index in the quadrature point q_point.
Note
The name of the function is supposed to be read as "the jump
(singular) in the gradients (plural: one or two possible gradients)
of the shape function (singular)".
Return the jump in the gradient on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+
Return the jump in the gradient on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the Hessians (plural: one or two possible values
for the second derivative) of the shape function (singular)".
Return the jump in the third derivative on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+
Return the jump in the third derivative on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the jump
(singular) in the third derivatives (plural: one or two possible values
for the third derivative) of the shape function (singular)".
Return the average vector on the interface for the shape function interface_dof_index in the quadrature point q_point.
+
Return the average vector on the interface for the shape function interface_dof_index in the quadrature point q_point.
Note
The name of the function is supposed to be read as "the average
(singular) of the values (plural: one or two possible values) of
the shape function (singular)".
Return the average of the gradient (a tensor of rank 2) on the interface for the shape function interface_dof_index in the quadrature point q_point.
+
Return the average of the gradient (a tensor of rank 2) on the interface for the shape function interface_dof_index in the quadrature point q_point.
Note
The name of the function is supposed to be read as "the average
(singular) of the gradients (plural: one or two possible values
of the derivative) of the shape function (singular)".
Return the average of the Hessian on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
+u_{\text{cell1}}$" src="form_1170.png"/> on the interface for the shape function interface_dof_index at the quadrature point q_point of the component selected by this view.
Note
The name of the function is supposed to be read as "the average
(singular) in the Hessians (plural: one or two possible values of
the second derivative) of the shape function (singular)".
@@ -733,7 +733,7 @@
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -1022,7 +1022,7 @@
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
A class to calculate expansion of a scalar FE (or a single component of vector-valued 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 . For example in 1d the L2-orthogonality condition reads
-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 . For example in 1d the L2-orthogonality condition reads
+
+\]" src="form_1252.png"/>
-
Note that .
+
Note that .
The arbitrary scalar FE field on the reference element can be expanded in the complete orthogonal exponential basis as
-
+\]" src="form_1254.png"/>
From the orthogonality property of the basis, it follows that
-
+\]" src="form_1255.png"/>
-
It is this complex-valued expansion coefficients, that are calculated by this class. Note that , where are real-valued FiniteElement shape functions. Consequently and we only need to compute for positive indices .
+
It is this complex-valued expansion coefficients, that are calculated by this class. Note that , where are real-valued FiniteElement shape functions. Consequently and we only need to compute for positive indices .
/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 2024-12-27 18:24:55.660783477 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFESeries_1_1Legendre.html 2024-12-27 18:24:55.664783505 +0000
@@ -209,39 +209,39 @@
template<int dim, int spacedim = dim>
class FESeries::Legendre< dim, spacedim >
A class to calculate expansion of a scalar FE (or a single component of vector-valued FE) field into series of Legendre functions on a reference element.
Legendre functions are solutions to Legendre's differential equation
-
+\]" src="form_1261.png"/>
and can be expressed using Rodrigues' formula
-
+\]" src="form_1262.png"/>
-
These polynomials are orthogonal with respect to the inner product on the interval
- inner product on the interval
+
+\]" src="form_1265.png"/>
-
and are complete. A family of -orthogonal polynomials on can be constructed via
--orthogonal polynomials on can be constructed via
+
+\]" src="form_1267.png"/>
-
An arbitrary scalar FE field on the reference element can be expanded in the complete orthogonal basis as
- can be expanded in the complete orthogonal basis as
+
+\]" src="form_1268.png"/>
From the orthogonality property of the basis, it follows that
-
+\]" src="form_1269.png"/>
-
This class calculates coefficients using -dimensional Legendre polynomials constructed from using tensor product rule.
+
This class calculates coefficients using -dimensional Legendre polynomials constructed from using tensor product rule.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFESubfaceValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFESubfaceValues.html 2024-12-27 18:24:55.768784219 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFESubfaceValues.html 2024-12-27 18:24:55.772784247 +0000
@@ -991,7 +991,7 @@
If the shape function is vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -1032,7 +1032,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -1071,7 +1071,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -1279,11 +1279,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
@@ -1859,7 +1859,7 @@
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2635,7 +2635,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2693,8 +2693,8 @@
-
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, pushed forward to the real cell coordinates, 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, pushed forward to the real cell coordinates, i.e. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_jacobian_pushed_forward_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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFESystem.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFESystem.html 2024-12-27 18:24:55.936785373 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFESystem.html 2024-12-27 18:24:55.936785373 +0000
@@ -520,11 +520,11 @@
This class provides an interface to group several elements together into one, vector-valued element. As example, consider the Taylor-Hood element that is used for the solution of the Stokes and Navier-Stokes equations: There, the velocity (of which there are as many components as the dimension of the domain) is discretized with elements and the pressure with elements. Mathematically, the finite element space for the coupled problem is then often written as where the exponentiation is understood to be the tensor product of spaces – i.e., in 2d, we have – and tensor products lead to vectors where each component of the vector-valued function space corresponds to a scalar function in one of the or spaces. Using the FESystem class, this space is created using
This class provides an interface to group several elements together into one, vector-valued element. As example, consider the Taylor-Hood element that is used for the solution of the Stokes and Navier-Stokes equations: There, the velocity (of which there are as many components as the dimension of the domain) is discretized with elements and the pressure with elements. Mathematically, the finite element space for the coupled problem is then often written as where the exponentiation is understood to be the tensor product of spaces – i.e., in 2d, we have – and tensor products lead to vectors where each component of the vector-valued function space corresponds to a scalar function in one of the or spaces. Using the FESystem class, this space is created using
The creation of this element here corresponds to taking tensor-product powers of the element in the first line of the list of arguments to the FESystem constructor, and then concatenation via another tensor product with the element in the second line. This kind of construction is used, for example, in the step-22 tutorial program.
+
The creation of this element here corresponds to taking tensor-product powers of the element in the first line of the list of arguments to the FESystem constructor, and then concatenation via another tensor product with the element in the second line. This kind of construction is used, for example, in the step-22 tutorial program.
Similarly, step-8 solves an elasticity equation where we need to solve for the displacement of a solid object. The displacement again has components if the domain is -dimensional, and so the combined finite element is created using
where now each (vector) component of the combined element corresponds to a space.
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 vector-valued – 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.
@@ -3817,7 +3817,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3919,7 +3919,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -4123,8 +4123,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValues.html 2024-12-27 18:24:56.044786114 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValues.html 2024-12-27 18:24:56.044786114 +0000
@@ -761,7 +761,7 @@
If the shape function is vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -800,7 +800,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -837,7 +837,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -1031,11 +1031,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
@@ -1555,7 +1555,7 @@
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2273,7 +2273,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2327,8 +2327,8 @@
-
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, pushed forward to the real cell coordinates, 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, pushed forward to the real cell coordinates, i.e. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_jacobian_pushed_forward_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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesBase.html 2024-12-27 18:24:56.144786801 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesBase.html 2024-12-27 18:24:56.148786828 +0000
@@ -650,7 +650,7 @@
If the shape function is vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -684,7 +684,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -716,7 +716,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -882,11 +882,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
std::vector< std::vector< Tensor< 1, spacedim, Number > > > &
gradients&#href_anchor"memdoc">
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -1967,7 +1967,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2009,8 +2009,8 @@
-
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, pushed forward to the real cell coordinates, 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, pushed forward to the real cell coordinates, i.e. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_jacobian_pushed_forward_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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1RenumberedView.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1RenumberedView.html 2024-12-27 18:24:56.184787075 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1RenumberedView.html 2024-12-27 18:24:56.192787130 +0000
@@ -377,7 +377,7 @@
Return the values of the underlying view characterized by fe_function at the renumbered quadrature points.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the 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., value_type) times the type used to store the gradients of the unknowns of your finite element vector (represented by the 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., value_type) times the type used to store the gradients of the unknowns of your finite element vector (represented by the fe_function argument).
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Scalar.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Scalar.html 2024-12-27 18:24:56.228787378 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Scalar.html 2024-12-27 18:24:56.236787433 +0000
@@ -708,7 +708,7 @@
Return the values 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 FEValues object was called.
This function is the equivalent of the FEValuesBase::get_function_values function but it only works on the selected scalar component.
-
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the gradients 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the Laplacians 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 FEValues object was called. The Laplacians are the trace of the Hessians.
The data type stored by the output vector must be what you get when you multiply the Laplacians of shape functions (i.e., value_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the Laplacians of shape functions (i.e., value_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1SymmetricTensor_3_012_00_01dim_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1SymmetricTensor_3_012_00_01dim_00_01spacedim_01_4.html 2024-12-27 18:24:56.268787653 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1SymmetricTensor_3_012_00_01dim_00_01spacedim_01_4.html 2024-12-27 18:24:56.272787680 +0000
@@ -168,9 +168,9 @@
Detailed Description
template<int dim, int spacedim>
class FEValuesViews::SymmetricTensor< 2, dim, spacedim >
A class representing a view to a set of (dim*dim + dim)/2 components forming a symmetric second-order tensor from a vector-valued finite element. Views are discussed in the Handling vector valued problems topic.
-
This class allows to query the value and divergence of (components of) shape functions and solutions representing symmetric tensors. The divergence of a symmetric tensor is defined as , which due to the symmetry of the tensor is also . In other words, it due to the symmetry of it does not matter whether we apply the nabla operator by row or by column to get the divergence.
+
This class allows to query the value and divergence of (components of) shape functions and solutions representing symmetric tensors. The divergence of a symmetric tensor is defined as , which due to the symmetry of the tensor is also . In other words, it due to the symmetry of it does not matter whether we apply the nabla operator by row or by column to get the divergence.
Return the values of the selected vector components 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 FEValues object was called.
This function is the equivalent of the FEValuesBase::get_function_values function but it only works on the selected vector components.
-
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the divergence of the selected vector components 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 FEValues object was called.
There is no equivalent function such as FEValuesBase::get_function_divergences in the FEValues classes but the information can be obtained from FEValuesBase::get_function_gradients, of course.
See the general discussion of this class for a definition of the divergence.
-
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Tensor_3_012_00_01dim_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Tensor_3_012_00_01dim_00_01spacedim_01_4.html 2024-12-27 18:24:56.304787900 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Tensor_3_012_00_01dim_00_01spacedim_01_4.html 2024-12-27 18:24:56.304787900 +0000
@@ -181,8 +181,8 @@
Detailed Description
template<int dim, int spacedim>
class FEValuesViews::Tensor< 2, dim, spacedim >
A class representing a view to a set of dim*dim components forming a second-order tensor from a vector-valued finite element. Views are discussed in the Handling vector valued problems topic.
-
This class allows to query the value, gradient and divergence of (components of) shape functions and solutions representing tensors. The divergence of a tensor is defined as , whereas its gradient is .
+
This class allows to query the value, gradient and divergence of (components of) shape functions and solutions representing tensors. The divergence of a tensor is defined as , whereas its gradient is .
Return the values of the selected vector components 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 FEValues object was called.
This function is the equivalent of the FEValuesBase::get_function_values function but it only works on the selected vector components.
-
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the divergence of the selected vector components 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 FEValues object was called.
There is no equivalent function such as FEValuesBase::get_function_divergences in the FEValues classes but the information can be obtained from FEValuesBase::get_function_gradients, of course.
See the general discussion of this class for a definition of the divergence.
-
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return the gradient of the selected vector components 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 FEValues object was called.
See the general discussion of this class for a definition of the gradient.
-
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
/usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Vector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Vector.html 2024-12-27 18:24:56.352788230 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFEValuesViews_1_1Vector.html 2024-12-27 18:24:56.356788257 +0000
@@ -236,8 +236,8 @@
template<int dim, int spacedim = dim>
class FEValuesViews::Vector< dim, spacedim >
A class representing a view to a set of spacedim components forming a vector part of a vector-valued finite element. Views are discussed in the Handling vector valued problems topic.
Note that in the current context, a vector is meant in the sense physics uses it: it has spacedim components that behave in specific ways under coordinate system transformations. Examples include velocity or displacement fields. This is opposed to how mathematics uses the word "vector" (and how we use this word in other contexts in the library, for example in the Vector class), where it really stands for a collection of numbers. An example of this latter use of the word could be the set of concentrations of chemical species in a flame; however, these are really just a collection of scalar variables, since they do not change if the coordinate system is rotated, unlike the components of a velocity vector, and consequently, this class should not be used for this context.
-
This class allows to query the value, gradient and divergence of (components of) shape functions and solutions representing vectors. The gradient of a vector is defined as .
+
This class allows to query the value, gradient and divergence of (components of) shape functions and solutions representing vectors. The gradient of a vector is defined as .
Return the symmetric gradient (a symmetric tensor of rank 2) of the vector component selected by this view, for the shape function and quadrature point selected by the arguments.
The symmetric gradient is defined as , where represents the dim components selected from the FEValuesBase object, and is the location of the -th quadrature point.
+(\nabla \phi_i(x_q))^T]$" src="form_1335.png"/>, where represents the dim components selected from the FEValuesBase object, and is the location of the -th quadrature point.
Note
The meaning of the arguments is as documented for the value() function.
Return the values of the selected vector components 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 FEValues object was called.
This function is the equivalent of the FEValuesBase::get_function_values function but it only works on the selected vector components.
-
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the gradients of the selected vector components 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
The symmetric gradient of a vector field is defined as .
Note
There is no equivalent function such as FEValuesBase::get_function_symmetric_gradients in the FEValues classes but the information can be obtained from FEValuesBase::get_function_gradients, of course.
-
The data type stored by the output vector must be what you get when you multiply the symmetric gradients of shape functions (i.e., symmetric_gradient_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the symmetric gradients of shape functions (i.e., symmetric_gradient_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return the divergence of the selected vector components 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 FEValues object was called.
There is no equivalent function such as FEValuesBase::get_function_divergences in the FEValues classes but the information can be obtained from FEValuesBase::get_function_gradients, of course.
-
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the divergences of shape functions (i.e., divergence_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return the curl of the selected vector components 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 FEValues object was called.
There is no equivalent function such as FEValuesBase::get_function_curls in the FEValues classes but the information can be obtained from FEValuesBase::get_function_gradients, of course.
-
The data type stored by the output vector must be what you get when you multiply the curls of shape functions (i.e., curl_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the curls of shape functions (i.e., curl_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return the Hessians of the selected vector components 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Return the Laplacians of the selected vector components 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 FEValues object was called. The Laplacians are the trace of the Hessians.
The data type stored by the output vector must be what you get when you multiply the Laplacians of shape functions (i.e., laplacian_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
+
The data type stored by the output vector must be what you get when you multiply the Laplacians of shape functions (i.e., laplacian_type) times the type used to store the values of the unknowns of your finite element vector (represented by the fe_function argument).
Return 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 FEValues 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__ABF.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__ABF.html 2024-12-27 18:24:56.496789218 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__ABF.html 2024-12-27 18:24:56.508789301 +0000
@@ -764,11 +764,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3374,7 +3374,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3476,7 +3476,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3766,8 +3766,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BDM.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BDM.html 2024-12-27 18:24:56.664790372 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BDM.html 2024-12-27 18:24:56.668790400 +0000
@@ -740,11 +740,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3312,7 +3312,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3414,7 +3414,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3704,8 +3704,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BernardiRaugel.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BernardiRaugel.html 2024-12-27 18:24:56.808791361 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__BernardiRaugel.html 2024-12-27 18:24:56.816791416 +0000
@@ -740,11 +740,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3282,7 +3282,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3384,7 +3384,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3674,8 +3674,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Bernstein.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Bernstein.html 2024-12-27 18:24:56.960792405 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Bernstein.html 2024-12-27 18:24:56.968792460 +0000
@@ -2384,17 +2384,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2427,21 +2427,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3518,7 +3518,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3620,7 +3620,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3881,8 +3881,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3916,11 +3916,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGBDM.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGBDM.html 2024-12-27 18:24:57.108793421 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGBDM.html 2024-12-27 18:24:57.112793449 +0000
@@ -3156,7 +3156,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3258,7 +3258,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3548,8 +3548,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3583,11 +3583,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGNedelec.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGNedelec.html 2024-12-27 18:24:57.264794493 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGNedelec.html 2024-12-27 18:24:57.260794465 +0000
@@ -3156,7 +3156,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3258,7 +3258,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3548,8 +3548,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3583,11 +3583,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGP.html 2024-12-27 18:24:57.404795454 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGP.html 2024-12-27 18:24:57.408795481 +0000
@@ -491,24 +491,24 @@
Detailed Description
template<int dim, int spacedim = dim>
class FE_DGP< dim, spacedim >
Discontinuous finite elements based on Legendre polynomials.
-
This finite element implements complete polynomial spaces, that is, dim-dimensional polynomials of degree p. For example, in 2d the element FE_DGP(1) would represent the span of the functions , which is in contrast to the element FE_DGQ(1) that is formed by the span of . Since the DGP space has only three unknowns for each quadrilateral, it is immediately clear that this element can not be continuous.
-
The basis functions used in this element for the space described above are chosen to form a Legendre basis on the unit square, i.e., in particular they are -orthogonal and normalized on the reference cell (but not necessarily on the real cell). As a consequence, the first basis function of this element is always the function that is constant and equal to one, regardless of the polynomial degree of the element. In addition, as a result of the orthogonality of the basis functions, the mass matrix is diagonal if the grid cells are parallelograms. Note that this is in contrast to the FE_DGPMonomial class that actually uses the monomial basis listed above as basis functions, without transformation from reference to real cell.
+
This finite element implements complete polynomial spaces, that is, dim-dimensional polynomials of degree p. For example, in 2d the element FE_DGP(1) would represent the span of the functions , which is in contrast to the element FE_DGQ(1) that is formed by the span of . Since the DGP space has only three unknowns for each quadrilateral, it is immediately clear that this element can not be continuous.
+
The basis functions used in this element for the space described above are chosen to form a Legendre basis on the unit square, i.e., in particular they are -orthogonal and normalized on the reference cell (but not necessarily on the real cell). As a consequence, the first basis function of this element is always the function that is constant and equal to one, regardless of the polynomial degree of the element. In addition, as a result of the orthogonality of the basis functions, the mass matrix is diagonal if the grid cells are parallelograms. Note that this is in contrast to the FE_DGPMonomial class that actually uses the monomial basis listed above as basis functions, without transformation from reference to real cell.
The shape functions are defined in the class PolynomialSpace. The polynomials used inside PolynomialSpace are Polynomials::Legendre up to degree p given in FE_DGP. For the ordering of the basis functions, refer to PolynomialSpace, remembering that the Legendre polynomials are ordered by ascending degree.
Note
This element is not defined by finding shape functions within the given function space that interpolate a particular set of points. Consequently, there are no support points to which a given function could be interpolated; finding a finite element function that approximates a given function is therefore only possible through projection, rather than interpolation. Secondly, the shape functions of this element do not jointly add up to one. As a consequence of this, adding or subtracting a constant value – such as one would do to make a function have mean value zero – can not be done by simply subtracting the constant value from each degree of freedom. Rather, one needs to use the fact that the first basis function is constant equal to one and simply subtract the constant from the value of the degree of freedom corresponding to this first shape function on each cell.
This class is only partially implemented for the codimension one case (spacedim != dim ), since no passage of information between meshes of different refinement level is possible because the embedding and projection matrices are not computed in the class constructor.
Transformation properties
-
It is worth noting that under a (bi-, tri-)linear mapping, the space described by this element does not contain , even if we use a basis of polynomials of degree . Consequently, for example, on meshes with non-affine cells, a linear function can not be exactly represented by elements of type FE_DGP(1) or FE_DGPMonomial(1).
-
This can be understood by the following 2-d example: consider the cell with vertices at :
+
It is worth noting that under a (bi-, tri-)linear mapping, the space described by this element does not contain , even if we use a basis of polynomials of degree . Consequently, for example, on meshes with non-affine cells, a linear function can not be exactly represented by elements of type FE_DGP(1) or FE_DGPMonomial(1).
+
This can be understood by the following 2-d example: consider the cell with vertices at :
-
For this cell, a bilinear transformation produces the relations and that correlate reference coordinates and coordinates in real space . Under this mapping, the constant function is clearly mapped onto itself, but the two other shape functions of the space, namely and are mapped onto where .
-
For the simple case that , i.e. if the real cell is the unit square, the expressions can be simplified to and . However, for all other cases, the functions are not linear any more, and neither is any linear combination of them. Consequently, the linear functions are not within the range of the mapped polynomials.
+
For this cell, a bilinear transformation produces the relations and that correlate reference coordinates and coordinates in real space . Under this mapping, the constant function is clearly mapped onto itself, but the two other shape functions of the space, namely and are mapped onto where .
+
For the simple case that , i.e. if the real cell is the unit square, the expressions can be simplified to and . However, for all other cases, the functions are not linear any more, and neither is any linear combination of them. Consequently, the linear functions are not within the range of the mapped polynomials.
Visualization of shape functions
In 2d, the shape functions of this element look as follows.
-
element
+
element
@@ -517,11 +517,11 @@
-
element, shape function 0
+
element, shape function 0
-
element
+
element
@@ -533,9 +533,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -545,11 +545,11 @@
-
element, shape function 2
+
element, shape function 2
-
element
+
element
@@ -561,9 +561,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -576,9 +576,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -591,11 +591,11 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
-
element
+
element
@@ -607,9 +607,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -622,9 +622,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -637,9 +637,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -652,9 +652,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
@@ -667,11 +667,11 @@
-
element, shape function 8
+
element, shape function 8
-
element, shape function 9
+
element, shape function 9
-
element
+
element
@@ -683,9 +683,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -698,9 +698,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPMonomial.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPMonomial.html 2024-12-27 18:24:57.556796498 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPMonomial.html 2024-12-27 18:24:57.564796553 +0000
@@ -504,21 +504,21 @@
This finite element implements complete polynomial spaces, that is, dim-dimensional polynomials of degree p. For example, in 2d the element FE_DGP(1) would represent the span of the functions , which is in contrast to the element FE_DGQ(1) that is formed by the span of . Since the DGP space has only three unknowns for each quadrilateral, it is immediately clear that this element can not be continuous.
+
This finite element implements complete polynomial spaces, that is, dim-dimensional polynomials of degree p. For example, in 2d the element FE_DGP(1) would represent the span of the functions , which is in contrast to the element FE_DGQ(1) that is formed by the span of . Since the DGP space has only three unknowns for each quadrilateral, it is immediately clear that this element can not be continuous.
The basis functions for this element are chosen to be the monomials listed above. Note that this is the main difference to the FE_DGP class that uses a set of polynomials of complete degree p that form a Legendre basis on the unit square. Thus, there, the mass matrix is diagonal, if the grid cells are parallelograms. The basis here does not have this property; however, it is simpler to compute. On the other hand, this element has the additional disadvantage that the local cell matrices usually have a worse condition number than the ones originating from the FE_DGP element.
This class is not implemented for the codimension one case (spacedim != dim).
Transformation properties
-
It is worth noting that under a (bi-, tri-)linear mapping, the space described by this element does not contain , even if we use a basis of polynomials of degree . Consequently, for example, on meshes with non-affine cells, a linear function can not be exactly represented by elements of type FE_DGP(1) or FE_DGPMonomial(1).
-
This can be understood by the following 2-d example: consider the cell with vertices at :
+
It is worth noting that under a (bi-, tri-)linear mapping, the space described by this element does not contain , even if we use a basis of polynomials of degree . Consequently, for example, on meshes with non-affine cells, a linear function can not be exactly represented by elements of type FE_DGP(1) or FE_DGPMonomial(1).
+
This can be understood by the following 2-d example: consider the cell with vertices at :
-
For this cell, a bilinear transformation produces the relations and that correlate reference coordinates and coordinates in real space . Under this mapping, the constant function is clearly mapped onto itself, but the two other shape functions of the space, namely and are mapped onto where .
-
For the simple case that , i.e. if the real cell is the unit square, the expressions can be simplified to and . However, for all other cases, the functions are not linear any more, and neither is any linear combination of them. Consequently, the linear functions are not within the range of the mapped polynomials.
+
For this cell, a bilinear transformation produces the relations and that correlate reference coordinates and coordinates in real space . Under this mapping, the constant function is clearly mapped onto itself, but the two other shape functions of the space, namely and are mapped onto where .
+
For the simple case that , i.e. if the real cell is the unit square, the expressions can be simplified to and . However, for all other cases, the functions are not linear any more, and neither is any linear combination of them. Consequently, the linear functions are not within the range of the mapped polynomials.
Visualization of shape functions
In 2d, the shape functions of this element look as follows.
-
element
+
element
@@ -527,11 +527,11 @@
-
element, shape function 0
+
element, shape function 0
-
element
+
element
@@ -543,9 +543,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -555,11 +555,11 @@
-
element, shape function 2
+
element, shape function 2
-
element
+
element
@@ -571,9 +571,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -586,9 +586,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -601,11 +601,11 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
-
element
+
element
@@ -617,9 +617,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -632,9 +632,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -647,9 +647,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -662,9 +662,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
@@ -677,11 +677,11 @@
-
element, shape function 8
+
element, shape function 8
-
element, shape function 9
+
element, shape function 9
-
element
+
element
@@ -693,9 +693,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -708,9 +708,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -723,9 +723,9 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPNonparametric.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPNonparametric.html 2024-12-27 18:24:57.708797542 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGPNonparametric.html 2024-12-27 18:24:57.716797597 +0000
@@ -499,7 +499,7 @@
Besides, this class is not implemented for the codimension one case (spacedim != dim).
Visualization of shape functions
In 2d, the shape functions of this element look as follows.
-
element
+
element
@@ -508,11 +508,11 @@
-
element, shape function 0
+
element, shape function 0
-
element
+
element
@@ -524,9 +524,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -536,11 +536,11 @@
-
element, shape function 2
+
element, shape function 2
-
element
+
element
@@ -552,9 +552,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -567,9 +567,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -582,11 +582,11 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
-
element
+
element
@@ -598,9 +598,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -613,9 +613,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -628,9 +628,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -643,9 +643,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
@@ -658,11 +658,11 @@
-
element, shape function 8
+
element, shape function 8
-
element, shape function 9
+
element, shape function 9
-
element
+
element
@@ -674,9 +674,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -689,9 +689,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -704,9 +704,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -719,9 +719,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQ.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQ.html 2024-12-27 18:24:57.852798531 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQ.html 2024-12-27 18:24:57.856798558 +0000
@@ -530,7 +530,7 @@
*
with node 13 being placed in the interior of the hex.
Note, however, that these are just the Lagrange interpolation points of the shape functions. Even though they may physically be on the boundary of the cell, they are logically in the interior since there are no continuity requirements for these shape functions across cell boundaries. While discontinuous, when restricted to a single cell the shape functions of this element are exactly the same as those of the FE_Q element where they are shown visually.
Unit support point distribution and conditioning of interpolation
-
When constructing an FE_DGQ element at polynomial degrees one or two, equidistant support points at 0 and 1 (linear case) or 0, 0.5, and 1 (quadratic case) are used. The unit support or nodal points xi are those points where the jth Lagrange polynomial satisfies the property, i.e., where one polynomial is one and all the others are zero. For higher polynomial degrees, the support points are non-equidistant by default, and chosen to be the support points of the (degree+1)-order Gauss-Lobatto quadrature rule. This point distribution yields well-conditioned Lagrange interpolation at arbitrary polynomial degrees. By contrast, polynomials based on equidistant points get increasingly ill-conditioned as the polynomial degree increases. In interpolation, this effect is known as the Runge phenomenon. For Galerkin methods, the Runge phenomenon is typically not visible in the solution quality but rather in the condition number of the associated system matrices. For example, the elemental mass matrix of equidistant points at degree 10 has condition number 2.6e6, whereas the condition number for Gauss-Lobatto points is around 400.
+
When constructing an FE_DGQ element at polynomial degrees one or two, equidistant support points at 0 and 1 (linear case) or 0, 0.5, and 1 (quadratic case) are used. The unit support or nodal points xi are those points where the jth Lagrange polynomial satisfies the property, i.e., where one polynomial is one and all the others are zero. For higher polynomial degrees, the support points are non-equidistant by default, and chosen to be the support points of the (degree+1)-order Gauss-Lobatto quadrature rule. This point distribution yields well-conditioned Lagrange interpolation at arbitrary polynomial degrees. By contrast, polynomials based on equidistant points get increasingly ill-conditioned as the polynomial degree increases. In interpolation, this effect is known as the Runge phenomenon. For Galerkin methods, the Runge phenomenon is typically not visible in the solution quality but rather in the condition number of the associated system matrices. For example, the elemental mass matrix of equidistant points at degree 10 has condition number 2.6e6, whereas the condition number for Gauss-Lobatto points is around 400.
The Gauss-Lobatto points in 1d include the end points 0 and +1 of the unit interval. The interior points are shifted towards the end points, which gives a denser point distribution close to the element boundary.
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2337,21 +2337,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3481,7 +3481,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3583,7 +3583,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3844,8 +3844,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQArbitraryNodes.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQArbitraryNodes.html 2024-12-27 18:24:57.992799492 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQArbitraryNodes.html 2024-12-27 18:24:58.000799547 +0000
@@ -2188,17 +2188,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2231,21 +2231,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3375,7 +3375,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3477,7 +3477,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3738,8 +3738,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQHermite.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQHermite.html 2024-12-27 18:24:58.144800536 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQHermite.html 2024-12-27 18:24:58.144800536 +0000
@@ -2190,17 +2190,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2233,21 +2233,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3377,7 +3377,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3479,7 +3479,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3740,8 +3740,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQLegendre.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQLegendre.html 2024-12-27 18:24:58.296801580 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGQLegendre.html 2024-12-27 18:24:58.288801525 +0000
@@ -2190,17 +2190,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2233,21 +2233,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3377,7 +3377,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3479,7 +3479,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3740,8 +3740,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGRaviartThomas.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGRaviartThomas.html 2024-12-27 18:24:58.436802541 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGRaviartThomas.html 2024-12-27 18:24:58.444802596 +0000
@@ -3156,7 +3156,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3258,7 +3258,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3548,8 +3548,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3583,11 +3583,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGVector.html 2024-12-27 18:24:58.588803585 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__DGVector.html 2024-12-27 18:24:58.600803668 +0000
@@ -3173,7 +3173,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3275,7 +3275,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3565,8 +3565,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3600,11 +3600,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Enriched.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Enriched.html 2024-12-27 18:24:58.740804629 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Enriched.html 2024-12-27 18:24:58.744804656 +0000
@@ -500,12 +500,12 @@
Detailed Description
template<int dim, int spacedim = dim>
class FE_Enriched< dim, spacedim >
Implementation of a partition of unity finite element method (PUM) by Babuska and Melenk which enriches a standard finite element with an enrichment function multiplied with another (usually linear) finite element:
where and are the underlying finite elements (including the mapping from the isoparametric element to the real element); are the scalar enrichment functions in real space (e.g. , , etc); and are the standard and enriched DoFs. This allows to include in the finite element space a priori knowledge about the partial differential equation being solved which in turn improves the local approximation properties of the spaces. This can be useful for highly oscillatory solutions, problems with domain corners or on unbounded domains or sudden changes of boundary conditions. PUM method uses finite element spaces which satisfy the partition of unity property (e.g. FE_Q). Among other properties this makes the resulting space to reproduce enrichment functions exactly.
+
where and are the underlying finite elements (including the mapping from the isoparametric element to the real element); are the scalar enrichment functions in real space (e.g. , , etc); and are the standard and enriched DoFs. This allows to include in the finite element space a priori knowledge about the partial differential equation being solved which in turn improves the local approximation properties of the spaces. This can be useful for highly oscillatory solutions, problems with domain corners or on unbounded domains or sudden changes of boundary conditions. PUM method uses finite element spaces which satisfy the partition of unity property (e.g. FE_Q). Among other properties this makes the resulting space to reproduce enrichment functions exactly.
The simplest constructor of this class takes two finite element objects and an enrichment function to be used. For example
In this case, standard DoFs are distributed by FE_Q<dim>(2), whereas enriched DoFs are coming from a single finite element FE_Q<dim>(1) used with a single enrichment function function. In this case, the total number of DoFs on the enriched element is the sum of DoFs from FE_Q<dim>(2) and FE_Q<dim>(1).
-
As an example of an enrichment function, consider , which leads to the following shape functions on the unit element:
+
As an example of an enrichment function, consider , which leads to the following shape functions on the unit element:
@@ -526,7 +526,7 @@
1d element, base and enriched shape functions.
enriched shape function corresponding to the central vertex.
Note that evaluation of gradients (hessians) of the enriched shape functions or the finite element field requires evaluation of gradients (gradients and hessians) of the enrichment functions:
-
+\end{align*}" src="form_1155.png"/>
Using enriched and non-enriched FEs together
-
In most applications it is beneficial to introduce enrichments only in some part of the domain (e.g. around a crack tip) and use standard FE (e.g. FE_Q) elsewhere. This can be achieved by using the hp-finite element framework in deal.II that allows for the use of different elements on different cells. To make the resulting space continuous, it is then necessary for the DoFHandler class and DoFTools::make_hanging_node_constraints() function to be able to figure out what to do at the interface between enriched and non-enriched cells. Specifically, we want the degrees of freedom corresponding to enriched shape functions to be zero at these interfaces. These classes and functions can not to do this automatically, but the effect can be achieved by using not just a regular FE_Q on cells without enrichment, but to wrap the FE_Q into an FE_Enriched object without actually enriching it. This can be done as follows:
In most applications it is beneficial to introduce enrichments only in some part of the domain (e.g. around a crack tip) and use standard FE (e.g. FE_Q) elsewhere. This can be achieved by using the hp-finite element framework in deal.II that allows for the use of different elements on different cells. To make the resulting space continuous, it is then necessary for the DoFHandler class and DoFTools::make_hanging_node_constraints() function to be able to figure out what to do at the interface between enriched and non-enriched cells. Specifically, we want the degrees of freedom corresponding to enriched shape functions to be zero at these interfaces. These classes and functions can not to do this automatically, but the effect can be achieved by using not just a regular FE_Q on cells without enrichment, but to wrap the FE_Q into an FE_Enriched object without actually enriching it. This can be done as follows:
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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3335,7 +3335,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3625,8 +3625,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3660,11 +3660,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP.html 2024-12-27 18:24:58.888805645 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP.html 2024-12-27 18:24:58.892805673 +0000
@@ -3240,7 +3240,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3342,7 +3342,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3603,8 +3603,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3638,11 +3638,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP_3_011_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP_3_011_00_01spacedim_01_4.html 2024-12-27 18:24:59.028806607 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceP_3_011_00_01spacedim_01_4.html 2024-12-27 18:24:59.032806634 +0000
@@ -3449,7 +3449,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3551,7 +3551,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3808,8 +3808,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3843,11 +3843,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ.html 2024-12-27 18:24:59.180807651 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ.html 2024-12-27 18:24:59.176807623 +0000
@@ -3287,7 +3287,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3389,7 +3389,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3650,8 +3650,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ_3_011_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ_3_011_00_01spacedim_01_4.html 2024-12-27 18:24:59.316808585 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__FaceQ_3_011_00_01spacedim_01_4.html 2024-12-27 18:24:59.328808667 +0000
@@ -3000,7 +3000,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3102,7 +3102,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3359,8 +3359,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3394,11 +3394,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Hermite.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Hermite.html 2024-12-27 18:24:59.480809711 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Hermite.html 2024-12-27 18:24:59.476809683 +0000
@@ -493,8 +493,8 @@
This class implements a Hermite interpolation basis of maximum regularity elements (see [CiarletRiavart1972interpolation]). These bases are always of odd polynomial degree, have regularity and are defined up to polynomial degree , with larger degrees currently being ill-conditioned.
-
Each node has degrees of freedom (DoFs) assigned to it, corresponding to various derivatives up to order in each direction. DoFs at each node are not consecutive in lexicographic ordering for due to the tensor product construction of the basis. The ordering is determined by the direction of the derivative each function corresponds to; first by -derivatives, then , then . Locally over each element the DoFs are ordered similarly. See below for the local ordering for , where DoFs are ordered from 0 to :
+class FE_Hermite< dim, spacedim >
This class implements a Hermite interpolation basis of maximum regularity elements (see [CiarletRiavart1972interpolation]). These bases are always of odd polynomial degree, have regularity and are defined up to polynomial degree , with larger degrees currently being ill-conditioned.
+
Each node has degrees of freedom (DoFs) assigned to it, corresponding to various derivatives up to order in each direction. DoFs at each node are not consecutive in lexicographic ordering for due to the tensor product construction of the basis. The ordering is determined by the direction of the derivative each function corresponds to; first by -derivatives, then , then . Locally over each element the DoFs are ordered similarly. See below for the local ordering for , where DoFs are ordered from 0 to :
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2080,21 +2080,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3457,7 +3457,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3559,7 +3559,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3849,8 +3849,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3884,11 +3884,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -5180,7 +5180,7 @@
-
Variable storing the order of the highest derivative that the current FE_Hermite object can enforce continuity for. Here the order of derivative only counts in one spatial direction, so the derivative would be counted as a first order derivative of , as an example.
+
Variable storing the order of the highest derivative that the current FE_Hermite object can enforce continuity for. Here the order of derivative only counts in one spatial direction, so the derivative would be counted as a first order derivative of , as an example.
Several aspects of the implementation are experimental. For the moment, it is safe to use the element on globally refined meshes with consistent orientation of faces. See the todo entries below for more detailed caveats.
-
Implementation of Nédélec elements. The Nédélec space is designed to solve problems in which the solution only lives in the space , rather than in the more commonly used space . In other words, the solution must be a vector field whose curl is square integrable, but for which the gradient may not be square integrable. The typical application for this space (and these elements) is to the Maxwell equations and corresponding simplifications, such as the reduced version of the Maxwell equation that only involves the electric field which has to satisfy the equation in the time independent case when no currents are present, or the equation that the magnetic vector potential has to satisfy in the time independent case.
-
The defining characteristic of functions in is that they are in general discontinuous – but that if you draw a line in 2d (or a surface in 3d), then the tangential component(s) of the vector field must be continuous across the line (or surface) even though the normal component may not be. As a consequence, the Nédélec element is constructed in such a way that (i) it is vector-valued, (ii) the shape functions are discontinuous, but (iii) the tangential component(s) of the vector field represented by each shape function are continuous across the faces of cells.
+
Implementation of Nédélec elements. The Nédélec space is designed to solve problems in which the solution only lives in the space , rather than in the more commonly used space . In other words, the solution must be a vector field whose curl is square integrable, but for which the gradient may not be square integrable. The typical application for this space (and these elements) is to the Maxwell equations and corresponding simplifications, such as the reduced version of the Maxwell equation that only involves the electric field which has to satisfy the equation in the time independent case when no currents are present, or the equation that the magnetic vector potential has to satisfy in the time independent case.
+
The defining characteristic of functions in is that they are in general discontinuous – but that if you draw a line in 2d (or a surface in 3d), then the tangential component(s) of the vector field must be continuous across the line (or surface) even though the normal component may not be. As a consequence, the Nédélec element is constructed in such a way that (i) it is vector-valued, (ii) the shape functions are discontinuous, but (iii) the tangential component(s) of the vector field represented by each shape function are continuous across the faces of cells.
Other properties of the Nédélec element are that (i) it is not a primitive element ; (ii) the shape functions are defined so that certain integrals over the faces are either zero or one, rather than the common case of certain point values being either zero or one.
We follow the commonly used – though confusing – definition of the "degree" of Nédélec elements. Specifically, the "degree" of the element denotes the polynomial degree of the largest complete polynomial subspace contained in the finite element space, even if the space may contain shape functions of higher polynomial degree. The lowest order element is consequently FE_Nedelec(0), i.e., the Raviart-Thomas element "of degree
zero", even though the functions of this space are in general polynomials of degree one in each variable. This choice of "degree" implies that the approximation order of the function itself is degree+1, as with usual polynomial spaces. The numbering so chosen implies the sequence
-
+\]" src="form_1195.png"/>
Note that this follows the convention of Brezzi and Raviart, though not the one used in the original paper by Nédélec.
This class is not implemented for the codimension one case (spacedim != dim).
@@ -1405,11 +1405,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -4104,7 +4104,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -4206,7 +4206,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -4467,8 +4467,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ.html 2024-12-27 18:24:59.784811799 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ.html 2024-12-27 18:24:59.784811799 +0000
@@ -2985,7 +2985,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3087,7 +3087,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3377,8 +3377,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3412,11 +3412,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ_1_1InternalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ_1_1InternalData.html 2024-12-27 18:24:59.828812101 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__NedelecSZ_1_1InternalData.html 2024-12-27 18:24:59.832812128 +0000
@@ -160,9 +160,9 @@
class FE_NedelecSZ< dim, spacedim >::InternalData
Derived Internal data which is used to store cell-independent data. Note that due to the nature of this element, a number of useful pre-computed quantities are stored for the computation of cell-dependent shape functions.
The main quantities which are stored are associated with edge and face parameterizations. These are:
- - trilinear function, equal to one at the -th vertex and zero at all other vertices.
+ - trilinear function, equal to one at the -th vertex and zero at all other vertices.
- - linear functional associated with the -th vertex.
+ - linear functional associated with the -th vertex.
The definitions of these functionals, as well as the edge and face parameterizations and edge and face extension parameters, can be found on page 82 of Zaglmayr's thesis. The details of the definition of the globally-defined edge and face orientations can be found on page 67.
@@ -295,9 +295,9 @@
Storage for all possible edge parameterization between vertices. These are required in the computation of edge- and face-based DoFs, which are cell-dependent.
-
The edge parameterization of an edge, E, starting at vertex i and ending at vertex is given by .
-
sigma_imj_values[q][i][j] stores the value of the edge parameterization connected by vertices and at the q-th quadrature point.
-
Note that not all of the and combinations result in valid edges on the hexahedral cell, but they are computed in this fashion for use with non-standard edge and face orientations.
+
The edge parameterization of an edge, E, starting at vertex i and ending at vertex is given by .
+
sigma_imj_values[q][i][j] stores the value of the edge parameterization connected by vertices and at the q-th quadrature point.
+
Note that not all of the and combinations result in valid edges on the hexahedral cell, but they are computed in this fashion for use with non-standard edge and face orientations.
Storage for gradients of all possible edge parameterizations between vertices. These are required in the computation of edge- and face-based DoFs, which are cell-dependent. Note that the components of the gradient are constant.
-
The edge parameterization of an edge, , starting at vertex and ending at vertex is given by .
-
sigma_imj_grads[i][j][d] stores the gradient of the edge parameterization connected by vertices and in component .
+
The edge parameterization of an edge, , starting at vertex and ending at vertex is given by .
+
sigma_imj_grads[i][j][d] stores the gradient of the edge parameterization connected by vertices and in component .
Note that the gradient of the edge parameterization is constant on an edge, so we do not need to store it at every quadrature point.
Storage for edge extension parameters at quadrature points. These are stored for the 12 edges such that the global vertex numbering would follow the order defined by the "standard" deal.II cell.
-
The edge extension parameter of an edge, , starting at vertex and ending at vertex is given by .
-
Note that under this definition, the values of do not change with the orientation of the edge.
-
edge_lambda_values[m][q] stores the edge extension parameter value at the -th quadrature point on edge .
+
The edge extension parameter of an edge, , starting at vertex and ending at vertex is given by .
+
Note that under this definition, the values of do not change with the orientation of the edge.
+
edge_lambda_values[m][q] stores the edge extension parameter value at the -th quadrature point on edge .
Storage for gradients of edge extension parameters in 2d. In this case they are constant. These are stored for the 12 edges such that the global vertex numbering* would follow the order defined by the "standard" deal.II cell.
-
edge_lambda_grads_2d[m][d] stores the gradient of the edge extension parameter for component on edge .
+
edge_lambda_grads_2d[m][d] stores the gradient of the edge extension parameter for component on edge .
Storage for gradients of edge extension parameters in 3d. In this case they are non-constant. These are stored for the 12 edges such that the global vertex numbering* would follow the order defined by the "standard" deal.II cell.
-
edge_lambda_grads_3d[m][q][d] stores the gradient of the edge extension parameter for component at the -th quadrature point on edge m.
+
edge_lambda_grads_3d[m][q][d] stores the gradient of the edge extension parameter for component at the -th quadrature point on edge m.
Storage for 2nd derivatives of edge extension parameters in 3d, which are constant across the cell. These are stored for the 12 edges such that the global vertex numbering* would follow the order defined by the "standard" deal.II cell.
-
edge_lambda_gradgrads_3d[m][d1][d2] stores the 2nd derivatives of the edge extension parameters with respect to components d1 and d2 on edge .
+
edge_lambda_gradgrads_3d[m][d1][d2] stores the 2nd derivatives of the edge extension parameters with respect to components d1 and d2 on edge .
Storage for the face extension parameters. These are stored for the 6 faces such that the global vertex numbering would follow the order defined by the "standard" deal.II cell.
-
The face extension parameter of a face, F, defined by the vertices v1, v2, v3, v4 is given by .
-
Note that under this definition, the values of do not change with the orientation of the face.
-
face_lambda_values[m][q] stores the face extension parameter value at the -th quadrature point on face .
+
The face extension parameter of a face, F, defined by the vertices v1, v2, v3, v4 is given by .
+
Note that under this definition, the values of do not change with the orientation of the face.
+
face_lambda_values[m][q] stores the face extension parameter value at the -th quadrature point on face .
Storage for gradients of face extension parameters. These are stored for the 6 faces such that the global vertex numbering would follow the order defined by the "standard" deal.II cell.
-
face_lambda_grads[m][d] stores the gradient of the face extension parameters for component on face .
+
face_lambda_grads[m][d] stores the gradient of the face extension parameters for component on face .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Nothing.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Nothing.html 2024-12-27 18:24:59.968813062 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Nothing.html 2024-12-27 18:24:59.976813117 +0000
@@ -482,7 +482,7 @@
class FE_Nothing< dim, spacedim >
Definition of a finite element space with zero degrees of freedom and that, consequently, can only represent a single function: the zero function.
This class is useful (in the context of an hp-method) to represent empty cells in the triangulation on which no degrees of freedom should be allocated, or to describe a field that is extended by zero to a part of the domain where we don't need it. Thus a triangulation may be divided into two regions: an active region where normal elements are used, and an inactive region where FE_Nothing elements are used. The DoFHandler will therefore assign no degrees of freedom to the FE_Nothing cells, and this subregion is therefore implicitly deleted from the computation. step-10 and step-46 show use cases for this element. An interesting application for this element is also presented in the paper [Cangiani2012].
Finite elements are often best interpreted as forming a function space, i.e., a set of functions that form a vector space. One can indeed interpret FE_Nothing in this light: It corresponds to the function space , i.e., the set of functions that are zero everywhere. (The constructor can take an argument that, if greater than one, extends the space to one of vector-valued functions with more than one component, with all components equal to zero everywhere.) Indeed, this is a vector space since every linear combination of elements in the vector space is also an element in the vector space, as is every multiple of the single element zero. It is obvious that the function space has no degrees of freedom, thus the name of the class.
+
Finite elements are often best interpreted as forming a function space, i.e., a set of functions that form a vector space. One can indeed interpret FE_Nothing in this light: It corresponds to the function space , i.e., the set of functions that are zero everywhere. (The constructor can take an argument that, if greater than one, extends the space to one of vector-valued functions with more than one component, with all components equal to zero everywhere.) Indeed, this is a vector space since every linear combination of elements in the vector space is also an element in the vector space, as is every multiple of the single element zero. It is obvious that the function space has no degrees of freedom, thus the name of the class.
In situations such as those of step-46, one uses FE_Nothing on cells where one is not interested in a solution variable. For example, in fluid structure interaction problems, the fluid velocity is only defined on cells inside the fluid part of the domain. One then uses FE_Nothing on cells in the solid part of the domain to describe the finite element space for the velocity. In other words, the velocity lives everywhere conceptually, but it is identically zero in those parts of the domain where it is not of interest and doesn't use up any degrees of freedom there.
The question is what happens at the interface between areas where one is interested in the solution (and uses a "normal" finite element) and where one is not interested (and uses FE_Nothing): Should the solution at that interface be zero – i.e., we consider a "continuous" finite element field that happens to be zero in that area where FE_Nothing is used – or is there no requirement for continuity at the interface. In the deal.II language, this is encoded by what the function FiniteElement::compare_for_domination() returns: If the FE_Nothing "dominates", then the solution must be zero at the interface; if it does not, then there is no requirement and one can think of FE_Nothing as a function space that is in general discontinuous (i.e., there is no requirement for any kind of continuity at cell interfaces) but on every cell equal to zero.
@@ -2888,7 +2888,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -2990,7 +2990,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3251,8 +3251,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3286,11 +3286,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__P1NC.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__P1NC.html 2024-12-27 18:25:00.112814051 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__P1NC.html 2024-12-27 18:25:00.120814106 +0000
@@ -489,13 +489,13 @@
Detailed Description
Implementation of the scalar version of the P1 nonconforming finite element, a piecewise linear element on quadrilaterals in 2d. This implementation is only for 2d cells in a 2d space (i.e., codimension 0).
Unlike the usual continuous, conforming finite elements, the P1 nonconforming element does not enforce continuity across edges. However, it requires the continuity in an integral sense: any function in the space should have the same integral values on two sides of the common edge shared by two adjacent elements.
-
Thus, each function in the nonconforming element space can be discontinuous, and consequently not included in , just like the basis functions in Discontinuous Galerkin (DG) finite element spaces. On the other hand, basis functions in DG spaces are completely discontinuous across edges without any relation between the values from both sides. This is a reason why usual weak formulations for DG schemes contain additional penalty terms for jump across edges to control discontinuity. However, nonconforming elements usually do not need additional terms in their weak formulations because their integrals along edges are the same from both sides, i.e., there is some level of continuity.
+
Thus, each function in the nonconforming element space can be discontinuous, and consequently not included in , just like the basis functions in Discontinuous Galerkin (DG) finite element spaces. On the other hand, basis functions in DG spaces are completely discontinuous across edges without any relation between the values from both sides. This is a reason why usual weak formulations for DG schemes contain additional penalty terms for jump across edges to control discontinuity. However, nonconforming elements usually do not need additional terms in their weak formulations because their integrals along edges are the same from both sides, i.e., there is some level of continuity.
Dice Rule
Since any function in the P1 nonconforming space is piecewise linear on each element, the function value at the midpoint of each edge is same as the mean value on the edge. Thus the continuity of the integral value across each edge is equivalent to the continuity of the midpoint value of each edge in this case.
Thus for the P1 nonconforming element, the function values at midpoints on edges of a cell are important. The first attempt to define (local) degrees of freedom (DoFs) on a quadrilateral is by using midpoint values of a function.
However, these 4 functionals are not linearly independent because a linear function on 2d is uniquely determined by only 3 independent values. A simple observation reads that any linear function on a quadrilateral should satisfy the 'dice rule': the sum of two function values at the midpoints of the edge pair on opposite sides of a cell is equal to the sum of those at the midpoints of the other edge pair. This is called the 'dice rule' because the number of points on opposite sides of a dice always adds up to the same number as well (in the case of dice, to seven).
-
In formulas, the dice rule is written as for all in the function space where is the midpoint of the edge . Here, we assume the standard numbering convention for edges used in deal.II and described in class GeometryInfo.
+
In formulas, the dice rule is written as for all in the function space where is the midpoint of the edge . Here, we assume the standard numbering convention for edges used in deal.II and described in class GeometryInfo.
Conversely if 4 values at midpoints satisfying the dice rule are given, then there always exists the unique linear function which coincides with 4 midpoints values.
Due to the dice rule, three values at any three midpoints can determine the last value at the last midpoint. It means that the number of independent local functionals on a cell is 3, and this is also the dimension of the linear polynomial space on a cell in 2d.
For each vertex of given cell, there are two edges of which is one of end points. Consider a linear function such that it has value 0.5 at the midpoints of two adjacent edges, and 0.0 at the two midpoints of the other edges. Note that the set of these values satisfies the dice rule which is described above. We denote such a function associated with vertex by . Then the set of 4 shape functions is a partition of unity on a cell: . (This is easy to see: at each edge midpoint, the sum of the four function adds up to one because two functions have value 0.5 and the other value 0.0. Because the function is globally linear, the only function that can have value 1 at four points must also be globally equal to one.)
-
The following figures represent for with their midpoint values:
+*
For each vertex of given cell, there are two edges of which is one of end points. Consider a linear function such that it has value 0.5 at the midpoints of two adjacent edges, and 0.0 at the two midpoints of the other edges. Note that the set of these values satisfies the dice rule which is described above. We denote such a function associated with vertex by . Then the set of 4 shape functions is a partition of unity on a cell: . (This is easy to see: at each edge midpoint, the sum of the four function adds up to one because two functions have value 0.5 and the other value 0.0. Because the function is globally linear, the only function that can have value 1 at four points must also be globally equal to one.)
+
The following figures represent for with their midpoint values:
Return the coefficients of 4 local linear shape functions on given cell. For each local shape function, the array consists of three coefficients is in order of a,b and c.
+
Return the coefficients of 4 local linear shape functions on given cell. For each local shape function, the array consists of three coefficients is in order of a,b and c.
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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3054,7 +3054,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3338,8 +3338,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3373,11 +3373,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Poly.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Poly.html 2024-12-27 18:25:00.256815040 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Poly.html 2024-12-27 18:25:00.260815067 +0000
@@ -1420,17 +1420,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1465,21 +1465,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3013,7 +3013,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3115,7 +3115,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3405,8 +3405,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3440,11 +3440,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyFace.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyFace.html 2024-12-27 18:25:00.404816056 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyFace.html 2024-12-27 18:25:00.412816111 +0000
@@ -2973,7 +2973,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3081,7 +3081,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3391,8 +3391,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3428,11 +3428,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyTensor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyTensor.html 2024-12-27 18:25:00.560817128 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PolyTensor.html 2024-12-27 18:25:00.556817100 +0000
@@ -509,12 +509,12 @@
Similarly, in many cases, node functionals depend on the shape of the mesh cell, since they evaluate normal or tangential components on the faces. In order to allow for a set of transformations, the variable mapping_kind has been introduced. It needs be set in the constructor of a derived class.
Any derived class must decide on the polynomial space to use. This polynomial space should be implemented simply as a set of vector valued polynomials like PolynomialsBDM and PolynomialsRaviartThomas. In order to facilitate this implementation, which basis the polynomial space chooses is not of importance to the current class – as described next, this class handles the transformation from the basis chosen by the polynomial space template argument to the basis we want to use for finite element computations internally.
Determining the correct basis
-
In most cases, the basis used by the class that describes the polynomial space, , does not match the one we want to use for the finite element description, . Rather, we need to express the finite element shape functions as a linear combination of the basis provided by the polynomial space:
-, does not match the one we want to use for the finite element description, . Rather, we need to express the finite element shape functions as a linear combination of the basis provided by the polynomial space:
+
+\end{align*}" src="form_1225.png"/>
-
These expansion coefficients are typically computed in the constructors of derived classes. To facilitate this, this class at first (unless told otherwise, see below), assumes that the shape functions should be exactly the ones provided by the polynomial space. In the constructor of the derived class, one then typically has code of the form
// Now compute the inverse node matrix, generating the correct
+
These expansion coefficients are typically computed in the constructors of derived classes. To facilitate this, this class at first (unless told otherwise, see below), assumes that the shape functions should be exactly the ones provided by the polynomial space. In the constructor of the derived class, one then typically has code of the form
// Now compute the inverse node matrix, generating the correct
// basis functions from the raw ones. For a discussion of what
// exactly happens here, see FETools::compute_node_matrix.
The FETools::compute_node_matrix() function explains in more detail what exactly it computes, and how; in any case, the result is that inverse_node_matrix now contains the expansion coefficients , and the fact that this block of code now sets the matrix to a non-zero size indicates to the functions of the current class that it should from then on use the expanded basis, , and no longer the original, "raw" basis when asked for values or derivatives of shape functions.
+
The FETools::compute_node_matrix() function explains in more detail what exactly it computes, and how; in any case, the result is that inverse_node_matrix now contains the expansion coefficients , and the fact that this block of code now sets the matrix to a non-zero size indicates to the functions of the current class that it should from then on use the expanded basis, , and no longer the original, "raw" basis when asked for values or derivatives of shape functions.
In order for this scheme to work, it is important to ensure that the size of the inverse_node_matrix be zero at the time when FETools::compute_node_matrix() is called; thus, the call to this function cannot be inlined into the last line – the result of the call really does need to be stored in the temporary object M.
Setting the transformation
In most cases, vector valued basis functions must be transformed when mapped from the reference cell to the actual grid cell. These transformations can be selected from the set MappingKind and stored in mapping_kind. Therefore, each constructor should contain a line like:
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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3014,7 +3014,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3304,8 +3304,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3339,11 +3339,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidDGP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidDGP.html 2024-12-27 18:25:00.704818117 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidDGP.html 2024-12-27 18:25:00.704818117 +0000
@@ -714,11 +714,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1735,17 +1735,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1778,21 +1778,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3268,7 +3268,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3370,7 +3370,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3660,8 +3660,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidP.html 2024-12-27 18:25:00.856819160 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidP.html 2024-12-27 18:25:00.852819133 +0000
@@ -851,11 +851,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1872,17 +1872,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1915,21 +1915,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3292,7 +3292,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3394,7 +3394,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3684,8 +3684,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidPoly.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidPoly.html 2024-12-27 18:25:00.996820122 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__PyramidPoly.html 2024-12-27 18:25:01.000820149 +0000
@@ -658,11 +658,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1685,17 +1685,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1728,21 +1728,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3276,7 +3276,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3378,7 +3378,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3668,8 +3668,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q.html 2024-12-27 18:25:01.152821193 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q.html 2024-12-27 18:25:01.156821220 +0000
@@ -508,7 +508,7 @@
The constructor creates a TensorProductPolynomials object that includes the tensor product of LagrangeEquidistant polynomials of degree p. This TensorProductPolynomials object provides all values and derivatives of the shape functions. In case a quadrature rule is given, the constructor creates a TensorProductPolynomials object that includes the tensor product of Lagrange polynomials with the support points from points.
Furthermore the constructor fills the interface_constraints, the prolongation (embedding) and the restriction matrices. These are implemented only up to a certain degree and may not be available for very high polynomial degree.
Unit support point distribution and conditioning of interpolation
-
When constructing an FE_Q element at polynomial degrees one or two, equidistant support points at 0 and 1 (linear case) or 0, 0.5, and 1 (quadratic case) are used. The unit support or nodal points xi are those points where the jth Lagrange polynomial satisfies the property, i.e., where one polynomial is one and all the others are zero. For higher polynomial degrees, the support points are non-equidistant by default, and chosen to be the support points of the (degree+1)-order Gauss-Lobatto quadrature rule. This point distribution yields well-conditioned Lagrange interpolation at arbitrary polynomial degrees. By contrast, polynomials based on equidistant points get increasingly ill-conditioned as the polynomial degree increases. In interpolation, this effect is known as the Runge phenomenon. For Galerkin methods, the Runge phenomenon is typically not visible in the solution quality but rather in the condition number of the associated system matrices. For example, the elemental mass matrix of equidistant points at degree 10 has condition number 2.6e6, whereas the condition number for Gauss-Lobatto points is around 400.
+
When constructing an FE_Q element at polynomial degrees one or two, equidistant support points at 0 and 1 (linear case) or 0, 0.5, and 1 (quadratic case) are used. The unit support or nodal points xi are those points where the jth Lagrange polynomial satisfies the property, i.e., where one polynomial is one and all the others are zero. For higher polynomial degrees, the support points are non-equidistant by default, and chosen to be the support points of the (degree+1)-order Gauss-Lobatto quadrature rule. This point distribution yields well-conditioned Lagrange interpolation at arbitrary polynomial degrees. By contrast, polynomials based on equidistant points get increasingly ill-conditioned as the polynomial degree increases. In interpolation, this effect is known as the Runge phenomenon. For Galerkin methods, the Runge phenomenon is typically not visible in the solution quality but rather in the condition number of the associated system matrices. For example, the elemental mass matrix of equidistant points at degree 10 has condition number 2.6e6, whereas the condition number for Gauss-Lobatto points is around 400.
The Gauss-Lobatto points in 1d include the end points 0 and +1 of the unit interval. The interior points are shifted towards the end points, which gives a denser point distribution close to the element boundary.
If combined with Gauss-Lobatto quadrature, FE_Q based on the default support points gives diagonal mass matrices. This case is demonstrated in step-48. However, this element can be combined with arbitrary quadrature rules through the usual FEValues approach, including full Gauss quadrature. In the general case, the mass matrix is non-diagonal.
Numbering of the degrees of freedom (DoFs)
@@ -694,9 +694,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -709,9 +709,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -724,9 +724,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -739,9 +739,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
@@ -751,7 +751,7 @@
-
element, shape function 8
+
element, shape function 8
@@ -920,9 +920,9 @@
-
element, shape function 0
+
element, shape function 0
-
element, shape function 1
+
element, shape function 1
@@ -935,9 +935,9 @@
-
element, shape function 2
+
element, shape function 2
-
element, shape function 3
+
element, shape function 3
@@ -950,9 +950,9 @@
-
element, shape function 4
+
element, shape function 4
-
element, shape function 5
+
element, shape function 5
@@ -965,9 +965,9 @@
-
element, shape function 6
+
element, shape function 6
-
element, shape function 7
+
element, shape function 7
@@ -980,9 +980,9 @@
-
element, shape function 8
+
element, shape function 8
-
element, shape function 9
+
element, shape function 9
@@ -995,9 +995,9 @@
-
element, shape function 10
+
element, shape function 10
-
element, shape function 11
+
element, shape function 11
@@ -1010,9 +1010,9 @@
-
element, shape function 12
+
element, shape function 12
-
element, shape function 13
+
element, shape function 13
@@ -1025,9 +1025,9 @@
-
element, shape function 14
+
element, shape function 14
-
element, shape function 15
+
element, shape function 15
@@ -1040,9 +1040,9 @@
-
element, shape function 16
+
element, shape function 16
-
element, shape function 17
+
element, shape function 17
@@ -1055,9 +1055,9 @@
-
element, shape function 18
+
element, shape function 18
-
element, shape function 19
+
element, shape function 19
@@ -1070,9 +1070,9 @@
-
element, shape function 20
+
element, shape function 20
-
element, shape function 21
+
element, shape function 21
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Base.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Base.html 2024-12-27 18:25:01.296822181 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Base.html 2024-12-27 18:25:01.300822209 +0000
@@ -2265,17 +2265,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2308,21 +2308,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3486,7 +3486,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3588,7 +3588,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3849,8 +3849,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3884,11 +3884,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Bubbles.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Bubbles.html 2024-12-27 18:25:01.452823253 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Bubbles.html 2024-12-27 18:25:01.448823226 +0000
@@ -507,17 +507,17 @@
Implementation of a scalar Lagrange finite element that yields the finite element space of continuous, piecewise polynomials of degree p in each coordinate direction plus some (non-normalized) bubble enrichment space spanned by the additional shape function that yields the finite element space of continuous, piecewise polynomials of degree p in each coordinate direction plus some (non-normalized) bubble enrichment space spanned by the additional shape function . for . If is one, then the first factor disappears and one receives the usual bubble function centered at the mid-point of the cell. Because these last shape functions have polynomial degree is , the overall polynomial degree of the shape functions in the space described by this class is .
+\left[\prod_{i=0}^{dim-1}(x_i(1-x_i))\right]$" src="form_1233.png"/>. for . If is one, then the first factor disappears and one receives the usual bubble function centered at the mid-point of the cell. Because these last shape functions have polynomial degree is , the overall polynomial degree of the shape functions in the space described by this class is .
This class is realized using tensor product polynomials based on equidistant or given support points, in the same way as one can provide support points to the FE_Q class's constructors.
For more information about the spacedim template parameter check the documentation of the FiniteElement class, or the one of Triangulation.
-
Due to the fact that the enrichments are small almost everywhere for large , the condition number for the mass and stiffness matrix quickly increaseses with increasing . Below you see a comparison with FE_Q(QGaussLobatto(p+1)) for dim=1.
+
Due to the fact that the enrichments are small almost everywhere for large , the condition number for the mass and stiffness matrix quickly increaseses with increasing . Below you see a comparison with FE_Q(QGaussLobatto(p+1)) for dim=1.
-
Therefore, this element should be used with care for .
+
Therefore, this element should be used with care for .
Implementation
The constructor creates a TensorProductPolynomials object that includes the tensor product of LagrangeEquidistant polynomials of degree p plus the bubble enrichments. This TensorProductPolynomialsBubbles object provides all values and derivatives of the shape functions. In case a quadrature rule is given, the constructor creates a TensorProductPolynomialsBubbles object that includes the tensor product of Lagrange polynomials with the support points from points and the bubble enrichments as defined above.
Furthermore the constructor fills the interface_constrains, the prolongation (embedding) and the restriction matrices.
@@ -736,11 +736,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -2459,17 +2459,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2502,21 +2502,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3593,7 +3593,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3695,7 +3695,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3956,8 +3956,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__DG0.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__DG0.html 2024-12-27 18:25:01.596824242 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__DG0.html 2024-12-27 18:25:01.600824270 +0000
@@ -909,11 +909,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -2636,17 +2636,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2679,21 +2679,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3770,7 +3770,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3872,7 +3872,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -4133,8 +4133,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Hierarchical.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Hierarchical.html 2024-12-27 18:25:01.760825368 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__Hierarchical.html 2024-12-27 18:25:01.768825423 +0000
@@ -3219,17 +3219,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -3264,21 +3264,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -4658,7 +4658,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -4760,7 +4760,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -5021,8 +5021,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -5056,11 +5056,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__iso__Q1.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__iso__Q1.html 2024-12-27 18:25:01.904826357 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__Q__iso__Q1.html 2024-12-27 18:25:01.908826384 +0000
@@ -504,14 +504,14 @@
template<int dim, int spacedim = dim>
class FE_Q_iso_Q1< dim, spacedim >
Implementation of a scalar Lagrange finite element Qp-iso-Q1 that defines the finite element space of continuous, piecewise linear elements with p subdivisions in each coordinate direction. It yields an element with the same number of degrees of freedom as the Qp elements but using linear interpolation instead of higher order one. In other words, on every cell, the shape functions are not of higher order polynomial degree interpolating a set of node points, but are piecewise (bi-, tri-)linear within the cell and interpolating the same set of node points. This type of element is also called macro element in the literature as it can be seen as consisting of several smaller elements, namely pdim such sub-cells.
The numbering of degrees of freedom is done in exactly the same way as in FE_Q of degree p. See there for a detailed description on how degrees of freedom are numbered within one element.
-
This element represents a Q-linear finite element space on a reduced mesh of size h/p. Its effect is equivalent to using FE_Q of degree one on a finer mesh by a factor p if an equivalent quadrature is used. However, this element reduces the flexibility in the choice of (adaptive) mesh size by exactly this factor p, which typically reduces efficiency. On the other hand, comparing this element with p subdivisions to the FE_Q element of degree p on the same mesh shows that the convergence is typically much worse for smooth problems. In particular, Qp elements achieve interpolation orders of hp+1 in the norm, whereas these elements reach only (h/p)2. For these two reasons, this element is usually not very useful as a standalone. In addition, any evaluation of face terms on the boundaries within the elements becomes impossible with this element because deal.II does not have the equivalent of FEFaceValues for lower-dimensional integrals in the interior of cells.
+
This element represents a Q-linear finite element space on a reduced mesh of size h/p. Its effect is equivalent to using FE_Q of degree one on a finer mesh by a factor p if an equivalent quadrature is used. However, this element reduces the flexibility in the choice of (adaptive) mesh size by exactly this factor p, which typically reduces efficiency. On the other hand, comparing this element with p subdivisions to the FE_Q element of degree p on the same mesh shows that the convergence is typically much worse for smooth problems. In particular, Qp elements achieve interpolation orders of hp+1 in the norm, whereas these elements reach only (h/p)2. For these two reasons, this element is usually not very useful as a standalone. In addition, any evaluation of face terms on the boundaries within the elements becomes impossible with this element because deal.II does not have the equivalent of FEFaceValues for lower-dimensional integrals in the interior of cells.
Nonetheless, there are a few use cases where this element actually is useful:
Systems of PDEs where certain variables demand for higher resolutions than the others and the additional degrees of freedom should be spent on increasing the resolution of linears instead of higher order polynomials, and you do not want to use two different meshes for the different components. This can be the case when irregularities (shocks) appear in the solution and stabilization techniques are used that work for linears but not higher order elements.
-
Stokes/Navier Stokes systems such as the one discussed in step-22 could be solved with Q2-iso-Q1 elements for velocities instead of elements. Combined with pressures they give a stable mixed element pair. However, they perform worse than the standard (Taylor-Hood ) approach in most situations. (See, for example, [Boffi2011] .) This combination of subdivided elements for the velocity and non-subdivided elements for the pressure is sometimes called the "Bercovier-Pironneau
+
Stokes/Navier Stokes systems such as the one discussed in step-22 could be solved with Q2-iso-Q1 elements for velocities instead of elements. Combined with pressures they give a stable mixed element pair. However, they perform worse than the standard (Taylor-Hood ) approach in most situations. (See, for example, [Boffi2011] .) This combination of subdivided elements for the velocity and non-subdivided elements for the pressure is sometimes called the "Bercovier-Pironneau
element" and dates back to around the same time as the Taylor-Hood element (namely, the mid-1970s). For more information, see the paper by Bercovier and Pironneau from 1979 [Bercovier1979], and for the origins of the comparable Taylor-Hood element see [Taylor73] from 1973.
@@ -2406,17 +2406,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2449,21 +2449,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3540,7 +3540,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3642,7 +3642,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3903,8 +3903,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RT__Bubbles.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RT__Bubbles.html 2024-12-27 18:25:02.052827373 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RT__Bubbles.html 2024-12-27 18:25:02.060827428 +0000
@@ -510,7 +510,7 @@
class FE_RT_Bubbles< dim >
This class implements a curl-enhanced Raviart-Thomas elements, conforming with Hdiv space. The node functionals are defined as point values in Gauss-Lobatto points. These elements generate vector fields with normal components continuous between mesh cells. The purpose of this finite element is in localizing the interactions between degrees of freedom around the nodes when an appropriate quadrature rule is used, leading to a block-diagonal mass matrix (even with full-tensor coefficient).
The elements are defined through enrichment of classical Raviart-Thomas elements with extra curls, so that the Hdiv conformity is preserved, and the total number of degrees of freedom of FE_RT_Bubbles of order k is equal to the number of DoFs in dim copies of FE_Q of order k.
Note
Unlike Raviart-Thomas, the lowest possible order for this enhanced finite element is 1, i.e. .
-
The matching pressure space for FE_RT_Bubbles of order k is FE_DGQ of order k-1. With the exact integration, this pair yields -st order of convergence in -norm for a vector variable and -th order in -norm for a scalar one (same as ).
+
The matching pressure space for FE_RT_Bubbles of order k is FE_DGQ of order k-1. With the exact integration, this pair yields -st order of convergence in -norm for a vector variable and -th order in -norm for a scalar one (same as ).
For this enhanced Raviart-Thomas element, the node values are not cell and face moments with respect to certain polynomials, but the values in Gauss-Lobatto quadrature points. The nodal values on edges (faces in 3d) are evaluated first, according to the natural ordering of the edges (faces) of a cell. The interior degrees of freedom are evaluated last.
For an RT-Bubbles element of degree k, we choose (k+1)dim-1 Gauss-Lobatto points on each face. These points are ordered lexicographically with respect to the orientation of the face. In the interior of the cells, the values are computed using an anisotropic Gauss-Lobatto formula for integration. The mass matrix assembled with the use of this same quadrature rule, is block diagonal with blocks corresponding to quadrature points. See "Higher order multipoint flux
mixed finite element methods on quadrilaterals and hexahedra" for more details.
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3348,7 +3348,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3450,7 +3450,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3740,8 +3740,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RannacherTurek.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RannacherTurek.html 2024-12-27 18:25:02.204828417 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RannacherTurek.html 2024-12-27 18:25:02.200828389 +0000
@@ -730,11 +730,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1859,17 +1859,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1904,21 +1904,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3394,7 +3394,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3496,7 +3496,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3786,8 +3786,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomas.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomas.html 2024-12-27 18:25:02.360829489 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomas.html 2024-12-27 18:25:02.356829461 +0000
@@ -519,11 +519,11 @@
Implementation of Raviart-Thomas (RT) elements. The Raviart-Thomas space is designed to solve problems in which the solution only lives in the space , rather than in the more commonly used space . In other words, the solution must be a vector field whose divergence is square integrable, but for which the gradient may not be square integrable. The typical application for this space (and these elements) is to the mixed formulation of the Laplace equation and related situations, see for example step-20. The defining characteristic of functions in is that they are in general discontinuous – but that if you draw a line in 2d (or a surface in 3d), then the normal component of the vector field must be continuous across the line (or surface) even though the tangential component may not be. As a consequence, the Raviart-Thomas element is constructed in such a way that (i) it is vector-valued, (ii) the shape functions are discontinuous, but (iii) the normal component of the vector field represented by each shape function is continuous across the faces of cells.
+class FE_RaviartThomas< dim >
Implementation of Raviart-Thomas (RT) elements. The Raviart-Thomas space is designed to solve problems in which the solution only lives in the space , rather than in the more commonly used space . In other words, the solution must be a vector field whose divergence is square integrable, but for which the gradient may not be square integrable. The typical application for this space (and these elements) is to the mixed formulation of the Laplace equation and related situations, see for example step-20. The defining characteristic of functions in is that they are in general discontinuous – but that if you draw a line in 2d (or a surface in 3d), then the normal component of the vector field must be continuous across the line (or surface) even though the tangential component may not be. As a consequence, the Raviart-Thomas element is constructed in such a way that (i) it is vector-valued, (ii) the shape functions are discontinuous, but (iii) the normal component of the vector field represented by each shape function is continuous across the faces of cells.
Other properties of the Raviart-Thomas element are that (i) it is not a primitive element ; (ii) the shape functions are defined so that certain integrals over the faces are either zero or one, rather than the common case of certain point values being either zero or one. (There is, however, the FE_RaviartThomasNodal element that uses point values.)
We follow the commonly used – though confusing – definition of the "degree" of RT elements. Specifically, the "degree" of the element denotes the polynomial degree of the largest complete polynomial subspace contained in the finite element space, even if the space may contain shape functions of higher polynomial degree. The lowest order element is consequently FE_RaviartThomas(0), i.e., the Raviart-Thomas element "of
degree zero", even though the functions of this space are in general polynomials of degree one in each variable. This choice of "degree" implies that the approximation order of the function itself is degree+1, as with usual polynomial spaces. The numbering so chosen implies the sequence
-
+\]" src="form_1195.png"/>
This class is not implemented for the codimension one case (spacedim != dim).
Interpolation
@@ -798,11 +798,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3463,7 +3463,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3565,7 +3565,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3826,8 +3826,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomasNodal.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomasNodal.html 2024-12-27 18:25:02.516830560 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__RaviartThomasNodal.html 2024-12-27 18:25:02.516830560 +0000
@@ -811,11 +811,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -3482,7 +3482,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3584,7 +3584,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3874,8 +3874,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexDGP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexDGP.html 2024-12-27 18:25:02.652831494 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexDGP.html 2024-12-27 18:25:02.656831521 +0000
@@ -490,7 +490,7 @@
Implementation of a scalar discontinuous Lagrange finite element , sometimes denoted as , that yields the finite element space of discontinuous, piecewise polynomials of degree .
+class FE_SimplexDGP< dim, spacedim >
Implementation of a scalar discontinuous Lagrange finite element , sometimes denoted as , that yields the finite element space of discontinuous, piecewise polynomials of degree .
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -2071,17 +2071,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2114,21 +2114,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3344,7 +3344,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3446,7 +3446,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3707,8 +3707,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP.html 2024-12-27 18:25:02.792832455 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP.html 2024-12-27 18:25:02.800832510 +0000
@@ -490,7 +490,7 @@
Implementation of a scalar Lagrange finite element that yields the finite element space of continuous, piecewise polynomials of degree . The corresponding element on hypercube cells is FE_Q, on wegdes it is FE_WedgeP, and on pyramids it is FE_PyramidP.
+class FE_SimplexP< dim, spacedim >
Implementation of a scalar Lagrange finite element that yields the finite element space of continuous, piecewise polynomials of degree . The corresponding element on hypercube cells is FE_Q, on wegdes it is FE_WedgeP, and on pyramids it is FE_PyramidP.
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -2071,17 +2071,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2114,21 +2114,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3344,7 +3344,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3446,7 +3446,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3707,8 +3707,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP__Bubbles.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP__Bubbles.html 2024-12-27 18:25:02.936833444 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexP__Bubbles.html 2024-12-27 18:25:02.944833499 +0000
@@ -957,11 +957,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1978,17 +1978,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -2021,21 +2021,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3336,7 +3336,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3438,7 +3438,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3699,8 +3699,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexPoly.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexPoly.html 2024-12-27 18:25:03.084834460 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__SimplexPoly.html 2024-12-27 18:25:03.084834460 +0000
@@ -916,11 +916,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1943,17 +1943,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1986,21 +1986,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3359,7 +3359,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3461,7 +3461,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3722,8 +3722,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ.html 2024-12-27 18:25:03.228835449 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ.html 2024-12-27 18:25:03.236835504 +0000
@@ -3274,7 +3274,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3376,7 +3376,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3637,8 +3637,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ_3_011_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:03.376836466 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__TraceQ_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:03.376836466 +0000
@@ -3449,7 +3449,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3551,7 +3551,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3808,8 +3808,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3843,11 +3843,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeDGP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeDGP.html 2024-12-27 18:25:03.512837400 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeDGP.html 2024-12-27 18:25:03.520837454 +0000
@@ -714,11 +714,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1735,17 +1735,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1778,21 +1778,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3268,7 +3268,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3370,7 +3370,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3660,8 +3660,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeP.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeP.html 2024-12-27 18:25:03.664838443 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgeP.html 2024-12-27 18:25:03.668838471 +0000
@@ -851,11 +851,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1872,17 +1872,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1915,21 +1915,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3292,7 +3292,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3394,7 +3394,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3684,8 +3684,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgePoly.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgePoly.html 2024-12-27 18:25:03.800839377 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFE__WedgePoly.html 2024-12-27 18:25:03.808839432 +0000
@@ -658,11 +658,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
@@ -1685,17 +1685,17 @@
Correct the shape Hessians by subtracting the terms corresponding to the Jacobian pushed forward gradient.
Before the correction, the Hessians would be given by
-
+\]" src="form_1216.png"/>
-
where . After the correction, the correct Hessians would be given by
-. After the correction, the correct Hessians would be given by
+
+\]" src="form_1218.png"/>
-
where is the Jacobian pushed-forward derivative.
+
where is the Jacobian pushed-forward derivative.
@@ -1728,21 +1728,21 @@
Correct the shape third derivatives by subtracting the terms corresponding to the Jacobian pushed forward gradient and second derivative.
Before the correction, the third derivatives would be given by
-
+\]" src="form_1220.png"/>
-
where . After the correction, the correct third derivative would be given by
-. After the correction, the correct third derivative would be given by
+
+\]" src="form_1221.png"/>
-
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
+
where is the Jacobian pushed-forward derivative and is the Jacobian pushed-forward second derivative.
@@ -3276,7 +3276,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -3378,7 +3378,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -3668,8 +3668,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElement.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElement.html 2024-12-27 18:25:03.968840531 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElement.html 2024-12-27 18:25:03.968840531 +0000
@@ -501,7 +501,7 @@
class FiniteElement< dim, spacedim >
This is the base class for finite elements in arbitrary dimensions. It declares the interface both in terms of member variables and public member functions through which properties of a concrete implementation of a finite element can be accessed. This interface generally consists of a number of groups of variables and functions that can roughly be delineated as follows:
Basic information about the finite element, such as the number of degrees of freedom per vertex, edge, or cell. This kind of data is stored in the FiniteElementData base class. (Though the FiniteElement::get_name() member function also falls into this category.)
A description of the shape functions and their derivatives on the reference cell , if an element is indeed defined by mapping shape functions from the reference cell to an actual cell.
-
Matrices (and functions that access them) that describe how an element's shape functions related to those on parent or child cells (restriction or prolongation) or neighboring cells (for hanging node constraints), as well as to other finite element spaces defined on the same cell (e.g., when doing refinement).
+
Matrices (and functions that access them) that describe how an element's shape functions related to those on parent or child cells (restriction or prolongation) or neighboring cells (for hanging node constraints), as well as to other finite element spaces defined on the same cell (e.g., when doing refinement).
For elements that are interpolatory, such as the common Lagrange elements, data that describes where their support points are located.
Functions that define the interface to the FEValues class that is almost always used to access finite element shape functions from user code.
@@ -586,7 +586,7 @@
21
1
0
8
1
What we see is the following: there are a total of 22 degrees-of-freedom on this element with components ranging from 0 to 2. Each DoF corresponds to one of the two base elements used to build FESystem : or . Since FE_Q are primitive elements, we have a total of 9 distinct scalar-valued shape functions for the quadratic element and 4 for the linear element. Finally, for DoFs corresponding to the first base element multiplicity is either zero or one, meaning that we use the same scalar valued for both and components of the velocity field . For DoFs corresponding to the second base element multiplicity is zero.
+ Q_1$" src="form_1037.png"/>. Since FE_Q are primitive elements, we have a total of 9 distinct scalar-valued shape functions for the quadratic element and 4 for the linear element. Finally, for DoFs corresponding to the first base element multiplicity is either zero or one, meaning that we use the same scalar valued for both and components of the velocity field . For DoFs corresponding to the second base element multiplicity is zero.
Support points
Finite elements are frequently defined by defining a polynomial space and a set of dual functionals. If these functionals involve point evaluations, then the element is "interpolatory" and it is possible to interpolate an arbitrary (but sufficiently smooth) function onto the finite element space by evaluating it at these points. We call these points "support points".
Most finite elements are defined by mapping from the reference cell to a concrete cell. Consequently, the support points are then defined on the reference ("unit") cell, see this glossary entry. The support points on a concrete cell can then be computed by mapping the unit support points, using the Mapping class interface and derived classes, typically via the FEValues class.
@@ -618,8 +618,8 @@
Through this construction, the degrees of freedom on the child faces are constrained to the degrees of freedom on the parent face. The information so provided is typically consumed by the DoFTools::make_hanging_node_constraints() function.
For the interface constraints, the 3d case is similar to the 2d case. The numbering for the indices on the mother face is obvious and keeps to the usual numbering of degrees of freedom on quadrilaterals.
-
The numbering of the degrees of freedom on the interior of the refined faces for the index is as follows: let and be as above, and be the number of degrees of freedom per quadrilateral (and therefore per face), then denote the dofs on the vertex at the center, for the dofs on the vertices at the center of the bounding lines of the quadrilateral, are for the degrees of freedom on the four lines connecting the center vertex to the outer boundary of the mother face, for the degrees of freedom on the small lines surrounding the quad, and for the dofs on the four child faces. Note the direction of the lines at the boundary of the quads, as shown below.
+
For the interface constraints, the 3d case is similar to the 2d case. The numbering for the indices on the mother face is obvious and keeps to the usual numbering of degrees of freedom on quadrilaterals.
+
The numbering of the degrees of freedom on the interior of the refined faces for the index is as follows: let and be as above, and be the number of degrees of freedom per quadrilateral (and therefore per face), then denote the dofs on the vertex at the center, for the dofs on the vertices at the center of the bounding lines of the quadrilateral, are for the degrees of freedom on the four lines connecting the center vertex to the outer boundary of the mother face, for the degrees of freedom on the small lines surrounding the quad, and for the dofs on the four child faces. Note the direction of the lines at the boundary of the quads, as shown below.
The order of the twelve lines and the four child faces can be extracted from the following sketch, where the overall order of the different dof groups is depicted:
Writing things as the sum over matrix operations as above would not easily work because we have to add nonzero values to twice, once for each child.
@@ -2629,7 +2629,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
scalar
An object that represents a single scalar vector component of this finite element.
@@ -2713,7 +2713,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
Parameters
component_mask
The mask that selects individual components of the finite element
@@ -2967,8 +2967,8 @@
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
-
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
+
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 elements in 3d, every degree of freedom is defined by a shape function that we get by interpolating using support points that lie on the vertices of the cell. The support of these points of course extends to all edges connected to this vertex, as well as the adjacent faces and the cell interior, but we say that logically the degree of freedom is associated with the vertex as this is the lowest-dimensional object it is associated with. Likewise, for elements in 3d, the degrees of freedom with support points at edge midpoints would yield a value of GeometryPrimitive::line from this function, whereas those on the centers of faces in 3d would return GeometryPrimitive::quad.
+
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 in 3d, the shape function with support point at an edge midpoint has support on all cells that share the edge and not only the cells that share the adjacent faces, and consequently the function will return GeometryPrimitive::line.
On the other hand, for discontinuous elements of type , a degree of freedom associated with an interpolation polynomial that has its support point physically located at a line bounding a cell, but is nonzero only on one cell. Consequently, it is logically associated with the interior of that cell (i.e., with a GeometryPrimitive::quad in 2d and a GeometryPrimitive::hex in 3d).
Parameters
@@ -3004,11 +3004,11 @@
-
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
-
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
-
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
-
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
+
Given the values of a function at the (generalized) support points of the reference cell, this function then computes what the nodal values of the element are, i.e., , where are the node functionals of the element (see also Node values or node functionals). The values are then the expansion coefficients for the shape functions of the finite element function that interpolates the given function , i.e., is the finite element interpolant of with the current element. The operation described here is used, for example, in the FETools::compute_node_matrix() function.
+
In more detail, let us assume that the generalized support points (see this glossary entry ) of the current element are and that the node functionals associated with the current element are . Then, the fact that the element is based on generalized support points, implies that if we apply to a (possibly vector-valued) finite element function , the result must have the form – in other words, the value of the node functional applied to only depends on the values of at and not on values anywhere else, or integrals of , or any other kind of information.
+
The exact form of depends on the element. For example, for scalar Lagrange elements, we have that in fact . If you combine multiple scalar Lagrange elements via an FESystem object, then where is the result of the FiniteElement::system_to_component_index() function's return value's first component. In these two cases, is therefore simply the identity (in the scalar case) or a function that selects a particular vector component of its argument. On the other hand, for Raviart-Thomas elements, one would have that where is the normal vector of the face at which the shape function is defined.
+
Given all of this, what this function does is the following: If you input a list of values of a function at all generalized support points (where each value is in fact a vector of values with as many components as the element has), then this function returns a vector of values obtained by applying the node functionals to these values. In other words, if you pass in then you will get out a vector where equals dofs_per_cell.
Parameters
[in]
support_point_values
An array of size dofs_per_cell (which equals the number of points the get_generalized_support_points() function will return) where each element is a vector with as many entries as the element has vector components. This array should contain the values of a function at the generalized support points of the current element.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElementData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElementData.html 2024-12-27 18:25:04.024840915 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteElementData.html 2024-12-27 18:25:04.028840943 +0000
@@ -332,8 +332,8 @@
[in]
dofs_per_object
A vector that describes the number of degrees of freedom on geometrical objects for each dimension. This vector must have size dim+1, and entry 0 describes the number of degrees of freedom per vertex, entry 1 the number of degrees of freedom per line, etc. As an example, for the common Lagrange element in 2d, this vector would have elements (1,0,0). On the other hand, for a element in 3d, it would have entries (1,2,4,8).
[in]
n_components
Number of vector components of the element.
-
[in]
degree
The maximal polynomial degree of any of the shape functions of this element in any variable on the reference element. For example, for the element (in any space dimension), this would be one; this is so despite the fact that the element has a shape function of the form (in 2d) and (in 3d), which, although quadratic and cubic polynomials, are still only linear in each reference variable separately. The information provided by this variable is typically used in determining what an appropriate quadrature formula is.
-
[in]
conformity
A variable describing which Sobolev space this element conforms to. For example, the Lagrange elements (implemented by the FE_Q class) are conforming, whereas the Raviart-Thomas element (implemented by the FE_RaviartThomas class) is conforming; finally, completely discontinuous elements (implemented by the FE_DGQ class) are only conforming.
+
[in]
degree
The maximal polynomial degree of any of the shape functions of this element in any variable on the reference element. For example, for the element (in any space dimension), this would be one; this is so despite the fact that the element has a shape function of the form (in 2d) and (in 3d), which, although quadratic and cubic polynomials, are still only linear in each reference variable separately. The information provided by this variable is typically used in determining what an appropriate quadrature formula is.
+
[in]
conformity
A variable describing which Sobolev space this element conforms to. For example, the Lagrange elements (implemented by the FE_Q class) are conforming, whereas the Raviart-Thomas element (implemented by the FE_RaviartThomas class) is conforming; finally, completely discontinuous elements (implemented by the FE_DGQ class) are only conforming.
[in]
block_indices
An argument that describes how the base elements of a finite element are grouped. The default value constructs a single block that consists of all dofs_per_cell degrees of freedom. This is appropriate for all "atomic" elements (including non-primitive ones) and these can therefore omit this argument. On the other hand, composed elements such as FESystem will want to pass a different value here.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteSizeHistory.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteSizeHistory.html 2024-12-27 18:25:04.056841135 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFiniteSizeHistory.html 2024-12-27 18:25:04.060841162 +0000
@@ -142,7 +142,7 @@
template<typename T>
class FiniteSizeHistory< T >
A helper class to store a finite-size collection of objects of type T. If the number of elements exceeds the specified maximum size of the container, the oldest element is removed. Additionally, random access and removal of elements is implemented. Indexing is done relative to the last added element.
In order to optimize the container for usage with memory-demanding objects (i.e. linear algebra vectors), the removal of an element does not free the memory. Instead the element is being kept in a separate cache so that subsequent addition does not require re-allocation of memory.
-
The primary usage of this class is in solvers to store a history of vectors. That is, if at the iteration we store vectors from previous iterations , then addition of the new element will make the object contain elements from iterations .
+
The primary usage of this class is in solvers to store a history of vectors. That is, if at the iteration we store vectors from previous iterations , then addition of the new element will make the object contain elements from iterations .
/usr/share/doc/packages/dealii/doxygen/deal.II/classFlatManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFlatManifold.html 2024-12-27 18:25:04.100841437 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFlatManifold.html 2024-12-27 18:25:04.104841464 +0000
@@ -473,7 +473,7 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
+
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
Note
If you use this class as a stepping stone to build a manifold that only "slightly" deviates from a flat manifold, by overloading the project_to_manifold() function.
Parameters
@@ -482,7 +482,7 @@
-
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
+
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFullMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFullMatrix.html 2024-12-27 18:25:04.160841849 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFullMatrix.html 2024-12-27 18:25:04.164841876 +0000
@@ -1096,8 +1096,8 @@
-
Return the l1-norm of the matrix, where (maximum of the sums over columns).
+
Return the l1-norm of the matrix, where (maximum of the sums over columns).
@@ -1117,8 +1117,8 @@
-
Return the -norm of the matrix, where (maximum of the sums over rows).
+
Return the -norm of the matrix, where (maximum of the sums over rows).
@@ -2071,7 +2071,7 @@
A=Inverse(A). A must be a square matrix. Inversion of this matrix by Gauss-Jordan algorithm with partial pivoting. This process is well-behaved for positive definite matrices, but be aware of round-off errors in the indefinite case.
In case deal.II was configured with LAPACK, the functions Xgetrf and Xgetri build an LU factorization and invert the matrix upon that factorization, providing best performance up to matrices with a few hundreds rows and columns.
-
The numerical effort to invert an matrix is of the order .
+
The numerical effort to invert an matrix is of the order .
@@ -2115,7 +2115,7 @@
-
Assign the Cholesky decomposition of the given matrix to *this, where is lower triangular matrix. The given matrix must be symmetric positive definite.
+
Assign the Cholesky decomposition of the given matrix to *this, where is lower triangular matrix. The given matrix must be symmetric positive definite.
ExcMatrixNotPositiveDefinite will be thrown in the case that the matrix is not positive definite.
If the functions you are dealing with have a number of components that are a priori known (for example, dim elements), you might consider using the TensorFunction class instead. This is, in particular, true if the objects you return have the properties of a tensor, i.e., they are for example dim-dimensional vectors or dim-by-dim matrices. On the other hand, functions like VectorTools::interpolate or VectorTools::interpolate_boundary_values definitely only want objects of the current type. You can use the VectorFunctionFromTensorFunction class to convert the former to the latter.
Most of the time, your functions will have the form . However, there are occasions where you want the function to return vectors (or scalars) over a different number field, for example functions that return complex numbers or vectors of complex numbers: . In such cases, you can choose a value different than the default double for the second template argument of this class: it describes the scalar type to be used for each component of your return values. It defaults to double, but in the example above, it could be set to std::complex<double>. step-58 is an example of this.
+
Most of the time, your functions will have the form . However, there are occasions where you want the function to return vectors (or scalars) over a different number field, for example functions that return complex numbers or vectors of complex numbers: . In such cases, you can choose a value different than the default double for the second template argument of this class: it describes the scalar type to be used for each component of your return values. It defaults to double, but in the example above, it could be set to std::complex<double>. step-58 is an example of this.
Template Parameters
-
dim
The space dimension of the range space within which the domain of the function lies. Consequently, the function will be evaluated at objects of type Point<dim>.
-
RangeNumberType
The scalar type of the vector space that is the range (or image) of this function. As discussed above, objects of the current type represent functions from to where is the underlying scalar type of the vector space. The type of is given by the RangeNumberType template argument.
+
dim
The space dimension of the range space within which the domain of the function lies. Consequently, the function will be evaluated at objects of type Point<dim>.
+
RangeNumberType
The scalar type of the vector space that is the range (or image) of this function. As discussed above, objects of the current type represent functions from to where is the underlying scalar type of the vector space. The type of is given by the RangeNumberType template argument.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionDerivative.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionDerivative.html 2024-12-27 18:25:04.272842618 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionDerivative.html 2024-12-27 18:25:04.272842618 +0000
@@ -360,27 +360,27 @@
Names of difference formulas.
Enumerator
Euler
The symmetric Euler formula of second order:
-
+\]" src="form_359.png"/>
UpwindEuler
The upwind Euler formula of first order:
-
+\]" src="form_360.png"/>
FourthOrder
The fourth order scheme
-
+\]" src="form_361.png"/>
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionManifold.html 2024-12-27 18:25:04.324842976 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionManifold.html 2024-12-27 18:25:04.328843003 +0000
@@ -553,7 +553,7 @@
-
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the sub_manifold coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the sub_manifold coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
This function is used in the computations required by the get_tangent_vector() function. The default implementation calls the get_gradient() method of the FunctionManifold::push_forward_function() member class. If you construct this object using the constructor that takes two string expression, then the default implementation of this method uses a finite difference scheme to compute the gradients(see the
AutoDerivativeFunction() class for details), and you can specify the size of the spatial step size at construction time with the h parameter.
Refer to the general documentation of this class for more information.
@@ -720,24 +720,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionParser.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionParser.html 2024-12-27 18:25:04.388843415 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctionParser.html 2024-12-27 18:25:04.396843470 +0000
@@ -522,27 +522,27 @@
Names of difference formulas.
Enumerator
Euler
The symmetric Euler formula of second order:
-
+\]" src="form_359.png"/>
UpwindEuler
The upwind Euler formula of first order:
-
+\]" src="form_360.png"/>
FourthOrder
The fourth order scheme
-
+\]" src="form_361.png"/>
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1CoordinateRestriction.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1CoordinateRestriction.html 2024-12-27 18:25:04.448843827 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1CoordinateRestriction.html 2024-12-27 18:25:04.452843855 +0000
@@ -228,7 +228,7 @@
Detailed Description
template<int dim>
-class Functions::CoordinateRestriction< dim >
This class takes a function in dim + 1 dimensions and creates a new function in one dimension lower by restricting one of the coordinates to a given value. Mathematically this corresponds to taking a function , a fixed value, , and defining a new function (the restriction) . Using this class, this translates to
This class takes a function in dim + 1 dimensions and creates a new function in one dimension lower by restricting one of the coordinates to a given value. Mathematically this corresponds to taking a function , a fixed value, , and defining a new function (the restriction) . Using this class, this translates to
The dim-dimensional coordinates on the restriction are ordered starting from the restricted (dim + 1)-coordinate. In particular, this means that if the -coordinate is locked to in 3d, the coordinates are ordered as on the restriction: . This is the same convention as in BoundingBox::cross_section.
+
The dim-dimensional coordinates on the restriction are ordered starting from the restricted (dim + 1)-coordinate. In particular, this means that if the -coordinate is locked to in 3d, the coordinates are ordered as on the restriction: . This is the same convention as in BoundingBox::cross_section.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedTensorProductGridData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedTensorProductGridData.html 2024-12-27 18:25:04.496844157 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedTensorProductGridData.html 2024-12-27 18:25:04.500844184 +0000
@@ -243,7 +243,7 @@
x=(x,y,z)$" src="form_492.png"/> will find the box so that , and do a trilinear interpolation of the data on this cell. Similar operations are done in lower dimensions.
This class is most often used for either evaluating coefficients or right hand sides that are provided experimentally at a number of points inside the domain, or for comparing outputs of a solution on a finite element mesh against previously obtained data defined on a grid.
-
Note
If the points are actually equally spaced on an interval and the same is true for the other data points in higher dimensions, you should use the InterpolatedUniformGridData class instead.
+
Note
If the points are actually equally spaced on an interval and the same is true for the other data points in higher dimensions, you should use the InterpolatedUniformGridData class instead.
If a point is requested outside the box defined by the end points of the coordinate arrays, then the function is assumed to simply extend by constant values beyond the last data point in each coordinate direction. (The class does not throw an error if a point lies outside the box since it frequently happens that a point lies just outside the box by an amount on the order of numerical roundoff.)
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedUniformGridData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedUniformGridData.html 2024-12-27 18:25:04.552844541 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1InterpolatedUniformGridData.html 2024-12-27 18:25:04.556844569 +0000
@@ -235,7 +235,7 @@
class Functions::InterpolatedUniformGridData< dim >
A scalar function that computes its values by (bi-, tri-)linear interpolation from a set of point data that are arranged on a uniformly spaced tensor product mesh. In other words, considering the three-dimensional case, let there be points that result from a uniform subdivision of the interval into sub-intervals of size , and similarly , . Also consider data defined at point , then evaluating the function at a point will find the box so that , and do a trilinear interpolation of the data on this cell. Similar operations are done in lower dimensions.
This class is most often used for either evaluating coefficients or right hand sides that are provided experimentally at a number of points inside the domain, or for comparing outputs of a solution on a finite element mesh against previously obtained data defined on a grid.
-
Note
If you have a problem where the points are not equally spaced (e.g., they result from a computation on a graded mesh that is denser closer to one boundary), then use the InterpolatedTensorProductGridData class instead.
+
Note
If you have a problem where the points are not equally spaced (e.g., they result from a computation on a graded mesh that is denser closer to one boundary), then use the InterpolatedTensorProductGridData class instead.
If a point is requested outside the box defined by the end points of the coordinate arrays, then the function is assumed to simply extend by constant values beyond the last data point in each coordinate direction. (The class does not throw an error if a point lies outside the box since it frequently happens that a point lies just outside the box by an amount on the order of numerical roundoff.)
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1LSingularityFunction.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1LSingularityFunction.html 2024-12-27 18:25:04.600844871 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1LSingularityFunction.html 2024-12-27 18:25:04.604844898 +0000
@@ -229,13 +229,13 @@
Detailed Description
A function that solves the Laplace equation (with specific boundary values but zero right hand side) and that has a singularity at the center of the L-shaped domain in 2d (i.e., at the location of the re-entrant corner of this non-convex domain).
The function is given in polar coordinates by with a singularity at the origin and should be used with GridGenerator::hyper_L(). Here, is defined as the clockwise angle against the positive -axis.
+\sin(\frac{2}{3} \phi)$" src="form_466.png"/> with a singularity at the origin and should be used with GridGenerator::hyper_L(). Here, is defined as the clockwise angle against the positive -axis.
This function is often used to illustrate that the solutions of the Laplace equation
-
can be singular even if the boundary values are smooth. (Here, if the domain is the L-shaped domain , the boundary values for are zero on the two line segments adjacent to the origin, and equal to on the remaining parts of the boundary.) The function itself remains bounded on the domain, but its gradient is of the form in the vicinity of the origin and consequently diverges as one approaches the origin.
+
can be singular even if the boundary values are smooth. (Here, if the domain is the L-shaped domain , the boundary values for are zero on the two line segments adjacent to the origin, and equal to on the remaining parts of the boundary.) The function itself remains bounded on the domain, but its gradient is of the form in the vicinity of the origin and consequently diverges as one approaches the origin.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1ParsedFunction.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1ParsedFunction.html 2024-12-27 18:25:04.660845283 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1ParsedFunction.html 2024-12-27 18:25:04.668845338 +0000
@@ -392,27 +392,27 @@
Names of difference formulas.
Enumerator
Euler
The symmetric Euler formula of second order:
-
+\]" src="form_359.png"/>
UpwindEuler
The upwind Euler formula of first order:
-
+\]" src="form_360.png"/>
FourthOrder
The fourth order scheme
-
+\]" src="form_361.png"/>
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1PointRestriction.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1PointRestriction.html 2024-12-27 18:25:04.712845640 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1PointRestriction.html 2024-12-27 18:25:04.716845667 +0000
@@ -231,7 +231,7 @@
Detailed Description
template<int dim>
-class Functions::PointRestriction< dim >
This class creates a 1-dimensional function from a dim + 1 dimensional function by restricting dim of the coordinate values to a given point. Mathematically this corresponds to taking a function, , and a point , and defining a new function . Using this class, this translates to
This class creates a 1-dimensional function from a dim + 1 dimensional function by restricting dim of the coordinate values to a given point. Mathematically this corresponds to taking a function, , and a point , and defining a new function . Using this class, this translates to
The coordinates of the point will be expanded in the higher-dimensional functions coordinates starting from the open-direction (and wrapping around). In particular, if we restrict to a point and choose to keep the y-direction open, the restriction that is created is the function . This is consistent with the convention in BoundingBox::cross_section.
+
The coordinates of the point will be expanded in the higher-dimensional functions coordinates starting from the open-direction (and wrapping around). In particular, if we restrict to a point and choose to keep the y-direction open, the restriction that is created is the function . This is consistent with the convention in BoundingBox::cross_section.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1Polynomial.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1Polynomial.html 2024-12-27 18:25:04.764845997 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1Polynomial.html 2024-12-27 18:25:04.772846052 +0000
@@ -332,8 +332,8 @@
const std::vector< double > &
coefficients&#href_anchor"memdoc">
-
Constructor. The coefficients and the exponents of the polynomial are passed as arguments. The Table<2, double> exponents has a number of rows equal to the number of monomials of the polynomial and a number of columns equal to dim. The i-th row of the exponents table contains the exponents of the i-th monomial . The i-th element of the coefficients vector contains the coefficient for the i-th monomial.
+
Constructor. The coefficients and the exponents of the polynomial are passed as arguments. The Table<2, double> exponents has a number of rows equal to the number of monomials of the polynomial and a number of columns equal to dim. The i-th row of the exponents table contains the exponents of the i-th monomial . The i-th element of the coefficients vector contains the coefficient for the i-th monomial.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1RayleighKotheVortex.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1RayleighKotheVortex.html 2024-12-27 18:25:04.812846327 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1RayleighKotheVortex.html 2024-12-27 18:25:04.816846354 +0000
@@ -226,7 +226,7 @@
Detailed Description
template<int dim>
class Functions::RayleighKotheVortex< dim >
A class that represents a time-dependent function object for a Rayleigh–Kothe vortex vector field. This is generally used as flow pattern in complex test cases for interface tracking methods (e.g., volume-of-fluid and level-set approaches) since it leads to strong rotation and elongation of the fluid [Blais2013].
-
The stream function of this Rayleigh-Kothe vortex is defined as:
+
The stream function of this Rayleigh-Kothe vortex is defined as:
template<int dim>
class Functions::SignedDistance::Ellipsoid< dim >
Signed-distance level set function to an ellipsoid defined by:
-
+\]" src="form_533.png"/>
-
Here, are the coordinates of the center of the ellipsoid and are the elliptic radii. This function is zero on the ellipsoid, negative inside the ellipsoid and positive outside the ellipsoid.
+
Here, are the coordinates of the center of the ellipsoid and are the elliptic radii. This function is zero on the ellipsoid, negative inside the ellipsoid and positive outside the ellipsoid.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Plane.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Plane.html 2024-12-27 18:25:04.924847096 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Plane.html 2024-12-27 18:25:04.928847123 +0000
@@ -226,7 +226,7 @@
Detailed Description
template<int dim>
-class Functions::SignedDistance::Plane< dim >
Signed level set function of a plane in : . Here, is the plane normal and is a point in the plane. Thus, with respect to the direction of the normal, this function is positive above the plane, zero in the plane, and negative below the plane. If the normal is normalized, will be the signed distance to the closest point in the plane.
+class Functions::SignedDistance::Plane< dim >
Signed level set function of a plane in : . Here, is the plane normal and is a point in the plane. Thus, with respect to the direction of the normal, this function is positive above the plane, zero in the plane, and negative below the plane. If the normal is normalized, will be the signed distance to the closest point in the plane.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Rectangle.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Rectangle.html 2024-12-27 18:25:04.980847480 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Rectangle.html 2024-12-27 18:25:04.984847508 +0000
@@ -226,7 +226,7 @@
Detailed Description
template<int dim>
class Functions::SignedDistance::Rectangle< dim >
Signed-distance level set function of a rectangle.
-
This function is zero on the rectangle, negative "inside" and positive in the rest of .
+
This function is zero on the rectangle, negative "inside" and positive in the rest of .
Contour surfaces of the signed distance function of a 3D rectangle are illustrated below:
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html 2024-12-27 18:25:05.032847837 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html 2024-12-27 18:25:05.036847865 +0000
@@ -226,9 +226,9 @@
Detailed Description
template<int dim>
-class Functions::SignedDistance::Sphere< dim >
Signed-distance level set function of a sphere: . Here, is the center of the sphere and is its radius. This function is thus zero on the sphere, negative "inside" the ball having the sphere as its boundary, and positive in the rest of .
-
This function has gradient and Hessian equal to , , where is the Kronecker delta function.
+class Functions::SignedDistance::Sphere< dim >
Signed-distance level set function of a sphere: . Here, is the center of the sphere and is its radius. This function is thus zero on the sphere, negative "inside" the ball having the sphere as its boundary, and positive in the rest of .
+
This function has gradient and Hessian equal to , , where is the Kronecker delta function.
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1ZalesakDisk.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1ZalesakDisk.html 2024-12-27 18:25:05.088848222 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1ZalesakDisk.html 2024-12-27 18:25:05.092848249 +0000
@@ -226,8 +226,8 @@
Detailed Description
template<int dim>
class Functions::SignedDistance::ZalesakDisk< dim >
Signed-distance level set function of Zalesak's disk proposed in [zalesak1979fully].
-
It is calculated by the set difference of the level set functions of a sphere and a rectangle . This function is zero on the surface of the disk, negative "inside" and positive in the rest of .
+
It is calculated by the set difference of the level set functions of a sphere and a rectangle . This function is zero on the surface of the disk, negative "inside" and positive in the rest of .
Contour surfaces of the signed distance function of a 3D Zalesak's disk are illustrated below:
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html 2024-12-27 18:25:05.144848606 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html 2024-12-27 18:25:05.148848634 +0000
@@ -275,7 +275,7 @@
Detailed Description
A singular solution to Stokes' equations on a 2d L-shaped domain.
-
This function satisfies and represents a typical singular solution around a reentrant corner of an L-shaped domain that can be created using GridGenerator::hyper_L(). The velocity vanishes on the two faces of the re-entrant corner and and are singular at the origin while they are smooth in the rest of the domain because they can be written as a product of a smooth function and the term where is the radius and is a fixed parameter.
+
This function satisfies and represents a typical singular solution around a reentrant corner of an L-shaped domain that can be created using GridGenerator::hyper_L(). The velocity vanishes on the two faces of the re-entrant corner and and are singular at the origin while they are smooth in the rest of the domain because they can be written as a product of a smooth function and the term where is the radius and is a fixed parameter.
Taken from Houston, Schötzau, Wihler, proceeding ENUMATH 2003.
/usr/share/doc/packages/dealii/doxygen/deal.II/classGridIn.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classGridIn.html 2024-12-27 18:25:05.196848963 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classGridIn.html 2024-12-27 18:25:05.204849018 +0000
@@ -920,7 +920,7 @@
Returns
This function returns a struct containing some extra data stored by the ExodusII file that cannot be loaded into a Triangulation - see ExodusIIData for more information.
-
A cell face in ExodusII can be in an arbitrary number of sidesets (i.e., it can have an arbitrary number of sideset ids) - however, a boundary cell face in deal.II has exactly one boundary id. All boundary faces that are not in a sideset are given the (default) boundary id of . This function then groups sidesets together into unique sets and gives each one a boundary id. For example: Consider a single-quadrilateral mesh whose left side has no sideset id, right side has sideset ids and , and whose bottom and top sides have sideset ids of . The left face will have a boundary id of , the top and bottom faces boundary ids of , and the right face a boundary id of . Hence the vector returned by this function in that case will be .
+
A cell face in ExodusII can be in an arbitrary number of sidesets (i.e., it can have an arbitrary number of sideset ids) - however, a boundary cell face in deal.II has exactly one boundary id. All boundary faces that are not in a sideset are given the (default) boundary id of . This function then groups sidesets together into unique sets and gives each one a boundary id. For example: Consider a single-quadrilateral mesh whose left side has no sideset id, right side has sideset ids and , and whose bottom and top sides have sideset ids of . The left face will have a boundary id of , the top and bottom faces boundary ids of , and the right face a boundary id of . Hence the vector returned by this function in that case will be .
/usr/share/doc/packages/dealii/doxygen/deal.II/classHouseholder.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classHouseholder.html 2024-12-27 18:25:05.228849183 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classHouseholder.html 2024-12-27 18:25:05.236849238 +0000
@@ -150,10 +150,10 @@
Detailed Description
template<typename number>
class Householder< number >
QR-decomposition of a full matrix.
-
This class computes the QR-decomposition of given matrix by the Householder algorithm. Then, the function least_squares() can be used to compute the vector minimizing for a given vector . The QR decomposition of is useful for this purpose because the minimizer is given by the equation which is easy to compute because is an orthogonal matrix, and consequently . Thus, . Furthermore, is triangular, so applying to a vector only involves a backward or forward solve.
+
This class computes the QR-decomposition of given matrix by the Householder algorithm. Then, the function least_squares() can be used to compute the vector minimizing for a given vector . The QR decomposition of is useful for this purpose because the minimizer is given by the equation which is easy to compute because is an orthogonal matrix, and consequently . Thus, . Furthermore, is triangular, so applying to a vector only involves a backward or forward solve.
Implementation details
-
The class does not in fact store the and factors explicitly as matrices. It does store , but the factor is stored as the product of Householder reflections of the form where the vectors are so that they can be stored in the lower-triangular part of an underlying matrix object, whereas is stored in the upper triangular part.
-
The vectors and the matrix now are in conflict because they both want to use the diagonal entry of the matrix, but we can only store one in these positions, of course. Consequently, the entries are stored separately in the diagonal member variable.
+
The class does not in fact store the and factors explicitly as matrices. It does store , but the factor is stored as the product of Householder reflections of the form where the vectors are so that they can be stored in the lower-triangular part of an underlying matrix object, whereas is stored in the upper triangular part.
+
The vectors and the matrix now are in conflict because they both want to use the diagonal entry of the matrix, but we can only store one in these positions, of course. Consequently, the entries are stored separately in the diagonal member variable.
Note
Instantiations for this template are provided for <float> and <double>; others can be generated in application programs (see the section on Template instantiations in the manual).
/usr/share/doc/packages/dealii/doxygen/deal.II/classIdentityMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classIdentityMatrix.html 2024-12-27 18:25:05.260849403 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classIdentityMatrix.html 2024-12-27 18:25:05.264849430 +0000
@@ -147,13 +147,13 @@
Detailed Description
-
Implementation of a simple class representing the identity matrix of a given size, i.e. a matrix with entries . While it has the most important ingredients of a matrix, in particular that one can ask for its size and perform matrix-vector products with it, a matrix of this type is really only useful in two contexts: preconditioning and initializing other matrices.
+
Implementation of a simple class representing the identity matrix of a given size, i.e. a matrix with entries . While it has the most important ingredients of a matrix, in particular that one can ask for its size and perform matrix-vector products with it, a matrix of this type is really only useful in two contexts: preconditioning and initializing other matrices.
Initialization
The main usefulness of this class lies in its ability to initialize other matrix, like this:
This creates a matrix with ones on the diagonal and zeros everywhere else. Most matrix types, in particular FullMatrix and SparseMatrix, have conversion constructors and assignment operators for IdentityMatrix, and can therefore be filled rather easily with identity matrices.
+
This creates a matrix with ones on the diagonal and zeros everywhere else. Most matrix types, in particular FullMatrix and SparseMatrix, have conversion constructors and assignment operators for IdentityMatrix, and can therefore be filled rather easily with identity matrices.
Preconditioning
No preconditioning at all is equivalent to preconditioning with preconditioning with the identity matrix. deal.II has a specialized class for this purpose, PreconditionIdentity, than can be used in a context as shown in the documentation of that class. The present class can be used in much the same way, although without any additional benefit:
A class to obtain the triangular matrix of the factorization together with the matrix itself. The orthonormal matrix is not stored explicitly, the name of the class. The multiplication with can be represented as , whereas the multiplication with is given by .
+class ImplicitQR< VectorType >
A class to obtain the triangular matrix of the factorization together with the matrix itself. The orthonormal matrix is not stored explicitly, the name of the class. The multiplication with can be represented as , whereas the multiplication with is given by .
The class is designed to update a given (possibly empty) QR factorization due to the addition of a new column vector. This is equivalent to constructing an orthonormal basis by the Gram-Schmidt procedure. The class also provides update functionality when the column is removed.
The VectorType template argument may either be a parallel and serial vector, and only need to have basic operations such as additions, scalar product, etc. It also needs to have a copy-constructor.
@@ -346,7 +346,7 @@
-
Set . The size of should be consistent with the size of the R matrix.
+
Set . The size of should be consistent with the size of the R matrix.
/usr/share/doc/packages/dealii/doxygen/deal.II/classIndexSet.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classIndexSet.html 2024-12-27 18:25:05.356850062 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classIndexSet.html 2024-12-27 18:25:05.360850089 +0000
@@ -863,7 +863,7 @@
-
Return whether the IndexSets are ascending with respect to MPI process number and 1:1, i.e., each index is contained in exactly one IndexSet (among those stored on the different processes), each process stores contiguous subset of indices, and the index set on process starts at the index one larger than the last one stored on process . In case there is only one MPI process, this just means that the IndexSet is complete.
+
Return whether the IndexSets are ascending with respect to MPI process number and 1:1, i.e., each index is contained in exactly one IndexSet (among those stored on the different processes), each process stores contiguous subset of indices, and the index set on process starts at the index one larger than the last one stored on process . In case there is only one MPI process, this just means that the IndexSet is complete.
This command takes a "mask", i.e., a second index set of same size as the current one and returns the intersection of the current index set the mask, shifted to the index of an entry within the given mask. For example, if the current object is a an IndexSet object representing an index space [0,100) containing indices [20,40), and if the mask represents an index space of the same size but containing all 50 odd indices in this range, then the result will be an index set for a space of size 50 that contains those indices that correspond to the question "the how many'th entry in the mask are the indices [20,40). This will result in an index set of size 50 that contains the indices {11,12,13,14,15,16,17,18,19,20} (because, for example, the index 20 in the original set is not in the mask, but 21 is and corresponds to the 11th entry of the mask – the mask contains the elements {1,3,5,7,9,11,13,15,17,19,21,...}).
In other words, the result of this operation is the intersection of the set represented by the current object and the mask, as seen within the mask. This corresponds to the notion of a view: The mask is a window through which we see the set represented by the current object.
-
A typical case where this function is useful is as follows. Say, you have a block linear system in which you have blocks corresponding to variables (which you can think of as velocity, pressure, temperature, and chemical composition – or whatever other kind of problem you are currently considering in your own work). We solve this in parallel, so every MPI process has its own locally_owned_dofs index set that describes which among all degrees of freedom this process owns. Let's assume we have developed a linear solver or preconditioner that first solves the coupled - system, and once that is done, solves the - system. In this case, it is often useful to set up block vectors with only two components corresponding to the and components, and later for only the - components of the solution. The question is which of the components of these 2-block vectors are locally owned? The answer is that we need to get a view of the locally_owned_dofs index set in which we apply a mask that corresponds to the variables we're currently interested in. For the - system, we need a mask (corresponding to an index set of size ) that contains all indices of degrees of freedom as well as all indices of degrees of freedom. The resulting view is an index set of size that contains the indices of the locally owned and degrees of freedom.
+
A typical case where this function is useful is as follows. Say, you have a block linear system in which you have blocks corresponding to variables (which you can think of as velocity, pressure, temperature, and chemical composition – or whatever other kind of problem you are currently considering in your own work). We solve this in parallel, so every MPI process has its own locally_owned_dofs index set that describes which among all degrees of freedom this process owns. Let's assume we have developed a linear solver or preconditioner that first solves the coupled - system, and once that is done, solves the - system. In this case, it is often useful to set up block vectors with only two components corresponding to the and components, and later for only the - components of the solution. The question is which of the components of these 2-block vectors are locally owned? The answer is that we need to get a view of the locally_owned_dofs index set in which we apply a mask that corresponds to the variables we're currently interested in. For the - system, we need a mask (corresponding to an index set of size ) that contains all indices of degrees of freedom as well as all indices of degrees of freedom. The resulting view is an index set of size that contains the indices of the locally owned and degrees of freedom.
Remove all elements contained in other from this set. In other words, if is the current object and the argument, then we compute is the current object and the argument, then we compute .
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
The vectors need to have the same layout.
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1ReadWriteVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1ReadWriteVector.html 2024-12-27 18:25:05.668852205 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1ReadWriteVector.html 2024-12-27 18:25:05.672852232 +0000
@@ -323,7 +323,7 @@
Detailed Description
template<typename Number>
-class LinearAlgebra::ReadWriteVector< Number >
ReadWriteVector is intended to represent vectors in for which it stores all or a subset of elements. The latter case in important in parallel computations, where may be so large that no processor can actually store all elements of a solution vector, but where this is also not necessary: one typically only has to store the values of degrees of freedom that live on cells that are locally owned plus potentially those degrees of freedom that live on ghost cells.
+class LinearAlgebra::ReadWriteVector< Number >
ReadWriteVector is intended to represent vectors in for which it stores all or a subset of elements. The latter case in important in parallel computations, where may be so large that no processor can actually store all elements of a solution vector, but where this is also not necessary: one typically only has to store the values of degrees of freedom that live on cells that are locally owned plus potentially those degrees of freedom that live on ghost cells.
This class provides access to individual elements to be read or written. However, it does not allow global operations such as taking the norm or dot products between vectors.
Storing elements
Most of the time, one will simply read from or write into a vector of the current class using the global numbers of these degrees of freedom. This is done using operator()() or operator[]() which call global_to_local() to transform the global index into a local one. In such cases, it is clear that one can only access elements of the vector that the current object indeed stores.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockSparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockSparseMatrix.html 2024-12-27 18:25:05.740852699 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockSparseMatrix.html 2024-12-27 18:25:05.748852754 +0000
@@ -1010,7 +1010,7 @@
-
Matrix-vector multiplication: let with being this matrix. The vector types can be block vectors or non-block vectors (only if the matrix has only one row or column, respectively), and need to define TrilinosWrappers::SparseMatrix::vmult.
+
Matrix-vector multiplication: let with being this matrix. The vector types can be block vectors or non-block vectors (only if the matrix has only one row or column, respectively), and need to define TrilinosWrappers::SparseMatrix::vmult.
Adding Matrix-vector multiplication. Add on with being this matrix.
+
Adding Matrix-vector multiplication. Add on with being this matrix.
@@ -2610,7 +2610,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Due to problems with deriving template arguments between the block and non-block 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.
@@ -2718,7 +2718,7 @@
-
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
+
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockVector.html 2024-12-27 18:25:05.812853194 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1BlockVector.html 2024-12-27 18:25:05.820853249 +0000
@@ -1562,7 +1562,7 @@
-
: scalar product.
+
: scalar product.
@@ -1588,7 +1588,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
@@ -1640,7 +1640,7 @@
-
Return the -norm of the vector, i.e. the sum of the absolute values.
+
Return the -norm of the vector, i.e. the sum of the absolute values.
@@ -1666,7 +1666,7 @@
-
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
+
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
@@ -1692,7 +1692,7 @@
-
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
+
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -1974,7 +1974,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparseMatrix.html 2024-12-27 18:25:05.888853716 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparseMatrix.html 2024-12-27 18:25:05.892853743 +0000
@@ -1845,7 +1845,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the SparseMatrix class used in deal.II (i.e. the original one, not the Trilinos wrapper class) since Trilinos doesn't support this operation and needs a temporary vector.
The vector has to be initialized with the same IndexSet the matrix was initialized with.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparsityPattern.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparsityPattern.html 2024-12-27 18:25:05.964854237 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1SparsityPattern.html 2024-12-27 18:25:05.964854237 +0000
@@ -477,7 +477,7 @@
-
Generate a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally, too.
+
Generate a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally, too.
It is possible to specify the number of columns entries per row using the optional n_entries_per_row argument. However, this value does not need to be accurate or even given at all, since one does usually not have this kind of information before building the sparsity pattern (the usual case when the function DoFTools::make_sparsity_pattern() is called). The entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes. However, a good estimate will reduce the setup time of the sparsity pattern.
Initialize a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally.
+
Initialize a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally.
The number of columns entries per row is specified as the maximum number of entries argument. This does not need to be an accurate number since the entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes, but a good estimate will reduce the setup time of the sparsity pattern.
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
+
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
The vectors need to have the same layout.
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1BlockVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1BlockVector.html 2024-12-27 18:25:06.112855254 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1BlockVector.html 2024-12-27 18:25:06.116855281 +0000
@@ -1357,7 +1357,7 @@
-
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
+
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
Calculate the scalar product between each block of this vector and V and store the result in a full matrix matrix. This function computes the result by forming where and indicate the th block (not element!) of and the th block of , respectively. If symmetric is true, it is assumed that inner product results in a square symmetric matrix and almost half of the scalar products can be avoided.
+
Calculate the scalar product between each block of this vector and V and store the result in a full matrix matrix. This function computes the result by forming where and indicate the th block (not element!) of and the th block of , respectively. If symmetric is true, it is assumed that inner product results in a square symmetric matrix and almost half of the scalar products can be avoided.
Obviously, this function can only be used if all blocks of both vectors are of the same size.
Note
Internally, a single global reduction will be called to accumulate scalar product between locally owned degrees of freedom.
Calculate the scalar product between each block of this vector and V using a metric tensor matrix. This function computes the result of where and indicate the th block (not element) of and the th block of , respectively. If symmetric is true, it is assumed that and are symmetric matrices and almost half of the scalar products can be avoided.
+
Calculate the scalar product between each block of this vector and V using a metric tensor matrix. This function computes the result of where and indicate the th block (not element) of and the th block of , respectively. If symmetric is true, it is assumed that and are symmetric matrices and almost half of the scalar products can be avoided.
Obviously, this function can only be used if all blocks of both vectors are of the same size.
Note
Internally, a single global reduction will be called to accumulate the scalar product between locally owned degrees of freedom.
@@ -1641,7 +1641,7 @@
const Number
b = Number(1.)&#href_anchor"memdoc">
-
Set each block of this vector as follows: where and indicate the th block (not element) of and the th block of , respectively.
+
Set each block of this vector as follows: where and indicate the th block (not element) of and the th block of , respectively.
Obviously, this function can only be used if all blocks of both vectors are of the same size.
@@ -1845,7 +1845,7 @@
-
Return the norm of the vector (i.e., the square root of the sum of the square of all entries among all processors).
+
Return the norm of the vector (i.e., the square root of the sum of the square of all entries among all processors).
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2563,7 +2563,7 @@
-
: scalar product.
+
: scalar product.
@@ -2597,7 +2597,7 @@
Performs a combined operation of a vector addition and a subsequent inner product, returning the value of the inner product. In other words, the result of this function is the same as if the user called
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2788,7 +2788,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1Vector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1Vector.html 2024-12-27 18:25:06.204855885 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearAlgebra_1_1distributed_1_1Vector.html 2024-12-27 18:25:06.204855885 +0000
@@ -1034,7 +1034,7 @@
Initialize vector with local_size locally-owned and ghost_size ghost degrees of freedoms.
The optional argument comm_sm, which consists of processes on the same shared-memory domain, allows users have read-only access to both locally-owned and ghost values of processes combined in the shared-memory communicator. See the general documentation of this class for more information about this argument.
-
Note
In the created underlying partitioner, the local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively. Setting the ghost_size variable to an appropriate value provides memory space for the ghost data in a vector's memory allocation as and allows access to it via local_element(). However, the associated global indices must be handled externally in this case.
+
Note
In the created underlying partitioner, the local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively. Setting the ghost_size variable to an appropriate value provides memory space for the ghost data in a vector's memory allocation as and allows access to it via local_element(). However, the associated global indices must be handled externally in this case.
@@ -1757,7 +1757,7 @@
-
Return the norm of the vector (i.e., the square root of the sum of the square of all entries among all processors).
+
Return the norm of the vector (i.e., the square root of the sum of the square of all entries among all processors).
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2453,7 +2453,7 @@
-
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
+
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
/usr/share/doc/packages/dealii/doxygen/deal.II/classLinearOperator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearOperator.html 2024-12-27 18:25:06.244856160 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classLinearOperator.html 2024-12-27 18:25:06.252856215 +0000
@@ -237,7 +237,7 @@
that store the knowledge how to initialize (resize + internal data structures) an arbitrary vector of the Range and Domain space.
The primary purpose of this class is to provide syntactic sugar for complex matrix-vector operations and free the user from having to create, set up and handle intermediate storage locations by hand.
-
As an example consider the operation , where , and denote (possible different) matrices. In order to construct a LinearOperatorop that stores the knowledge of this operation, one can write:
+
As an example consider the operation , where , and denote (possible different) matrices. In order to construct a LinearOperatorop that stores the knowledge of this operation, one can write:
/usr/share/doc/packages/dealii/doxygen/deal.II/classManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classManifold.html 2024-12-27 18:25:06.288856462 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classManifold.html 2024-12-27 18:25:06.292856490 +0000
@@ -204,11 +204,11 @@
In the most essential use of manifolds, manifold descriptions are used to create a "point between other points". For example, when a triangulation creates a new vertex on a cell, face, or edge, it determines the new vertex' coordinates through the following function call:
Here, points is a collection of points in spacedim dimension, and a collection of corresponding weights. The points in this context will then be the vertices of the cell, face, or edge, and the weights are typically one over the number of points when a new midpoint of the cell, face, or edge is needed. Derived classes then will implement the Manifold::get_new_point() function in a way that computes the location of this new point. In the simplest case, for example in the FlatManifold class, the function simply computes the arithmetic average (with given weights) of the given points. However, other classes do something differently; for example, the SphericalManifold class, which is used to describe domains that form (part of) the sphere, will ensure that, given the two vertices of an edge at the boundary, the new returned point will lie on the grand circle that connects the two points, rather than choosing a point that is half-way between the two points in .
+
Here, points is a collection of points in spacedim dimension, and a collection of corresponding weights. The points in this context will then be the vertices of the cell, face, or edge, and the weights are typically one over the number of points when a new midpoint of the cell, face, or edge is needed. Derived classes then will implement the Manifold::get_new_point() function in a way that computes the location of this new point. In the simplest case, for example in the FlatManifold class, the function simply computes the arithmetic average (with given weights) of the given points. However, other classes do something differently; for example, the SphericalManifold class, which is used to describe domains that form (part of) the sphere, will ensure that, given the two vertices of an edge at the boundary, the new returned point will lie on the grand circle that connects the two points, rather than choosing a point that is half-way between the two points in .
Note
Unlike almost all other cases in the library, we here interpret the points to be in real space, not on the reference cell.
Manifold::get_new_point() has a default implementation that can simplify this process somewhat: Internally, the function calls the Manifold::get_intermediate_point() to compute pair-wise intermediate points. Internally the Manifold::get_intermediate_point() calls the Manifold::project_to_manifold() function after computing the convex combination of the given points. This allows derived classes to only overload Manifold::project_to_manifold() for simple situations. This is often useful when describing manifolds that are embedded in higher dimensional space, e.g., the surface of a sphere. In those cases, the desired new point may be computed simply by the (weighted) average of the provided points, projected back out onto the sphere.
Common use case: Computing tangent vectors
-
The second use of this class is in computing directions on domains and boundaries. For example, we may need to compute the normal vector to a face in order to impose the no-flow boundary condition (see the VectorTools::compute_no_normal_flux_constraints() as an example). Similarly, we may need normal vectors in the computation of the normal component of the gradient of the numerical solution in order to compute the jump in the gradient of the solution in error estimators (see, for example, the KellyErrorEstimator class).
+
The second use of this class is in computing directions on domains and boundaries. For example, we may need to compute the normal vector to a face in order to impose the no-flow boundary condition (see the VectorTools::compute_no_normal_flux_constraints() as an example). Similarly, we may need normal vectors in the computation of the normal component of the gradient of the numerical solution in order to compute the jump in the gradient of the solution in error estimators (see, for example, the KellyErrorEstimator class).
To make this possible, the Manifold class provides a member function (to be implemented by derived classes) that computes a "vector tangent
to the manifold at one point, in direction of another point" via the Manifold::get_tangent_vector() function. For example, in 2d, one would use this function with the two vertices of an edge at the boundary to compute a "tangential" vector along the edge, and then get the normal vector by rotation by 90 degrees. In 3d, one would compute the two vectors "tangential" to the two edges of a boundary face adjacent to a boundary vertex, and then take the cross product of these two to obtain a vector normal to the boundary.
For reasons that are more difficult to understand, these direction vectors are normalized in a very specific way, rather than to have unit norm. See the documentation of Manifold::get_tangent_vector(), as well as below, for more information.
@@ -216,11 +216,11 @@
A unified description
The "real" way to understand what this class does is to see it in the framework of differential geometry. More specifically, differential geometry is fundamentally based on the assumption that two sufficiently close points are connected via a line of "shortest distance". This line is called a "geodesic", and it is selected from all other lines that connect the two points by the property that it is shortest if distances are measured in terms of the "metric" that describes a manifold. To give examples, recall that the geodesics of a flat manifold (implemented in the FlatManifold class) are simply the straight lines connecting two points, whereas for spherical manifolds (see the SphericalManifold class) geodesics between two points of same distance are the grand circles, and are in general curved lines when connecting two lines of different distance from the origin.
In the following discussion, and for the purposes of implementing the current class, the concept of "metrics" that is so fundamental to differential geometry is no longer of great importance to us. Rather, everything can simply be described by postulating the existence of geodesics connecting points on a manifold.
-
Given geodesics, the operations discussed in the previous two sections can be described in a more formal way. In essence, they rely on the fact that we can assume that a geodesic is parameterized by a "time" like variable so that describes the curve and so that is the location of the first and the location of the second point. Furthermore, traces out the geodesic at constant speed, covering equal distance in equal time (as measured by the metric). Note that this parameterization uses time, not arc length to denote progress along the geodesic.
-
In this picture, computing a mid-point between points and , with weights and , simply requires computing the point . Computing a new point as a weighted average of more than two points can be done by considering pairwise geodesics, finding suitable points on the geodetic between the first two points, then on the geodetic between this new point and the third given point, etc.
-
Likewise, the "tangential" vector described above is simply the velocity vector, , evaluated at one of the end points of a geodesic (i.e., at or ). In the case of a flat manifold, the geodesic is simply the straight line connecting two points, and the velocity vector is just the connecting vector in that case. On the other hand, for two points on a spherical manifold, the geodesic is a grand circle, and the velocity vector is tangent to the spherical surface.
-
Note that if we wanted to, we could use this to compute the length of the geodesic that connects two points and by computing along the geodesic that connects them, but this operation will not be of use to us in practice. One could also conceive computing the direction vector using the "new point" operation above, using the formula where all we need to do is compute the new point with weights and along the geodesic connecting and . The default implementation of the function does this, by evaluating the quotient for a small but finite weight . In practice, however, it is almost always possible to explicitly compute the direction vector, i.e., without the need to numerically approximate the limit process, and derived classes should do so.
+
Given geodesics, the operations discussed in the previous two sections can be described in a more formal way. In essence, they rely on the fact that we can assume that a geodesic is parameterized by a "time" like variable so that describes the curve and so that is the location of the first and the location of the second point. Furthermore, traces out the geodesic at constant speed, covering equal distance in equal time (as measured by the metric). Note that this parameterization uses time, not arc length to denote progress along the geodesic.
+
In this picture, computing a mid-point between points and , with weights and , simply requires computing the point . Computing a new point as a weighted average of more than two points can be done by considering pairwise geodesics, finding suitable points on the geodetic between the first two points, then on the geodetic between this new point and the third given point, etc.
+
Likewise, the "tangential" vector described above is simply the velocity vector, , evaluated at one of the end points of a geodesic (i.e., at or ). In the case of a flat manifold, the geodesic is simply the straight line connecting two points, and the velocity vector is just the connecting vector in that case. On the other hand, for two points on a spherical manifold, the geodesic is a grand circle, and the velocity vector is tangent to the spherical surface.
+
Note that if we wanted to, we could use this to compute the length of the geodesic that connects two points and by computing along the geodesic that connects them, but this operation will not be of use to us in practice. One could also conceive computing the direction vector using the "new point" operation above, using the formula where all we need to do is compute the new point with weights and along the geodesic connecting and . The default implementation of the function does this, by evaluating the quotient for a small but finite weight . In practice, however, it is almost always possible to explicitly compute the direction vector, i.e., without the need to numerically approximate the limit process, and derived classes should do so.
Return a vector that, at , is tangential to the geodesic that connects two points . The geodesic is the shortest line between these two points, where "shortest" is defined via a metric specific to a particular implementation of this class in a derived class. For example, in the case of a FlatManifold, the shortest line between two points is just the straight line, and in this case the tangent vector is just the difference . On the other hand, for a manifold that describes a surface embedded in a higher dimensional space (e.g., the surface of a sphere), then the tangent vector is tangential to the surface, and consequently may point in a different direction than the straight line that connects the two points.
-
While tangent vectors are often normalized to unit length, the vectors returned by this function are normalized as described in the introduction of this class. Specifically, if traces out the geodesic between the two points where and , then the returned vector must equal . In other words, the norm of the returned vector also encodes, in some sense, the length of the geodesic because a curve must move "faster" if the two points it connects between arguments and are farther apart.
-
The default implementation of this function approximates for a small value of , and the evaluation of is done by calling get_new_point(). If possible, derived classes should override this function by an implementation of the exact derivative.
+
Return a vector that, at , is tangential to the geodesic that connects two points . The geodesic is the shortest line between these two points, where "shortest" is defined via a metric specific to a particular implementation of this class in a derived class. For example, in the case of a FlatManifold, the shortest line between two points is just the straight line, and in this case the tangent vector is just the difference . On the other hand, for a manifold that describes a surface embedded in a higher dimensional space (e.g., the surface of a sphere), then the tangent vector is tangential to the surface, and consequently may point in a different direction than the straight line that connects the two points.
+
While tangent vectors are often normalized to unit length, the vectors returned by this function are normalized as described in the introduction of this class. Specifically, if traces out the geodesic between the two points where and , then the returned vector must equal . In other words, the norm of the returned vector also encodes, in some sense, the length of the geodesic because a curve must move "faster" if the two points it connects between arguments and are farther apart.
+
The default implementation of this function approximates for a small value of , and the evaluation of is done by calling get_new_point(). If possible, derived classes should override this function by an implementation of the exact derivative.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMapping.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMapping.html 2024-12-27 18:25:06.356856929 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMapping.html 2024-12-27 18:25:06.360856957 +0000
@@ -245,7 +245,7 @@
class Mapping< dim, spacedim >
Abstract base class for mapping classes.
This class declares the interface for the functionality to describe mappings from the reference (unit) cell to a cell in real space, as well as for filling the information necessary to use the FEValues, FEFaceValues, and FESubfaceValues classes. Concrete implementations of these interfaces are provided in derived classes.
Mathematics of the mapping
-
The mapping is a transformation which maps points in the reference cell to points in the actual grid cell . Many of the applications of such mappings require the Jacobian of this mapping, which maps points in the reference cell to points in the actual grid cell . Many of the applications of such mappings require the Jacobian of this mapping, . For instance, if dim=spacedim=2, we have
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
@@ -1350,18 +1350,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -1416,35 +1416,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -1501,21 +1501,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1565,40 +1565,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingC1.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingC1.html 2024-12-27 18:25:06.436857478 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingC1.html 2024-12-27 18:25:06.440857506 +0000
@@ -874,18 +874,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -940,35 +940,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -1025,21 +1025,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1089,40 +1089,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1459,7 +1459,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
@@ -1521,7 +1521,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingCartesian.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingCartesian.html 2024-12-27 18:25:06.504857945 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingCartesian.html 2024-12-27 18:25:06.508857973 +0000
@@ -231,9 +231,9 @@
Detailed Description
template<int dim, int spacedim = dim>
class MappingCartesian< dim, spacedim >
A class providing a mapping from the reference cell to cells that are axiparallel, i.e., that have the shape of rectangles (in 2d) or boxes (in 3d) with edges parallel to the coordinate directions. The class therefore provides functionality that is equivalent to what, for example, MappingQ would provide for such cells. However, knowledge of the shape of cells allows this class to be substantially more efficient.
-
Specifically, the mapping is meant for cells for which the mapping from the reference to the real cell is a scaling along the coordinate directions: The transformation from reference coordinates to real coordinates on each cell is of the form
- to real coordinates on each cell is of the form
+
+\end{align*}" src="form_1388.png"/>
in 2d, and
-
+\end{align*}" src="form_1389.png"/>
-
in 3d, where is the bottom left vertex and are the extents of the cell along the axes.
+
in 3d, where is the bottom left vertex and are the extents of the cell along the axes.
The class is intended for efficiency, and it does not do a whole lot of error checking. If you apply this mapping to a cell that does not conform to the requirements above, you will get strange results.
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -724,35 +724,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -811,21 +811,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -877,40 +877,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1173,7 +1173,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFE.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFE.html 2024-12-27 18:25:06.572858412 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFE.html 2024-12-27 18:25:06.576858440 +0000
@@ -715,18 +715,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -783,35 +783,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -870,21 +870,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -936,40 +936,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1190,7 +1190,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField.html 2024-12-27 18:25:06.648858934 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField.html 2024-12-27 18:25:06.652858962 +0000
@@ -785,18 +785,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -853,35 +853,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -940,21 +940,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1006,40 +1006,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1304,7 +1304,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField_1_1InternalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField_1_1InternalData.html 2024-12-27 18:25:06.688859209 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingFEField_1_1InternalData.html 2024-12-27 18:25:06.692859236 +0000
@@ -735,7 +735,7 @@
-
Tensors of contravariant transformation at each of the quadrature points. The contravariant matrix is the Jacobian of the transformation, i.e. .
+
Tensors of contravariant transformation at each of the quadrature points. The contravariant matrix is the Jacobian of the transformation, i.e. .
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold.html 2024-12-27 18:25:06.792859923 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold.html 2024-12-27 18:25:06.792859923 +0000
@@ -633,18 +633,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -701,35 +701,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -788,21 +788,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -854,40 +854,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1108,7 +1108,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold_1_1InternalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold_1_1InternalData.html 2024-12-27 18:25:06.832860198 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingManifold_1_1InternalData.html 2024-12-27 18:25:06.836860226 +0000
@@ -526,7 +526,7 @@
-
Tensors of contravariant transformation at each of the quadrature points. The contravariant matrix is the Jacobian of the transformation, i.e. .
+
Tensors of contravariant transformation at each of the quadrature points. The contravariant matrix is the Jacobian of the transformation, i.e. .
This class implements the functionality for polynomial mappings of polynomial degree that will be used on all cells of the mesh. In order to get a genuine higher-order mapping for all cells, it is important to provide information about how interior edges and faces of the mesh should be curved. This is typically done by associating a Manifold with interior cells and edges. A simple example of this is discussed in the "Results" section of step-6; a full discussion of manifolds is provided in step-53. If manifolds are only attached to the boundaries of a domain, the current class with higher polynomial degrees will provide the same information as a mere MappingQ1 object. If you are working on meshes that describe a (curved) manifold embedded in higher space dimensions, i.e., if dim!=spacedim, then every cell is at the boundary of the domain you will likely already have attached a manifold object to all cells that can then also be used by the mapping classes for higher order mappings.
+class MappingQ< dim, spacedim >
This class implements the functionality for polynomial mappings of polynomial degree that will be used on all cells of the mesh. In order to get a genuine higher-order mapping for all cells, it is important to provide information about how interior edges and faces of the mesh should be curved. This is typically done by associating a Manifold with interior cells and edges. A simple example of this is discussed in the "Results" section of step-6; a full discussion of manifolds is provided in step-53. If manifolds are only attached to the boundaries of a domain, the current class with higher polynomial degrees will provide the same information as a mere MappingQ1 object. If you are working on meshes that describe a (curved) manifold embedded in higher space dimensions, i.e., if dim!=spacedim, then every cell is at the boundary of the domain you will likely already have attached a manifold object to all cells that can then also be used by the mapping classes for higher order mappings.
Behavior along curved boundaries and with different manifolds
For a number of applications, one only knows a manifold description of a surface but not the interior of the computational domain. In such a case, a FlatManifold object will be assigned to the interior entities that describes a usual planar coordinate system where the additional points for the higher order mapping are placed exactly according to a bi-/trilinear mapping. When combined with a non-flat manifold on the boundary, for example a circle bulging into the interior of a square cell, the two manifold descriptions are in general incompatible. For example, a FlatManifold defined solely through the cell's vertices would put an interior point located at some small distance epsilon away from the boundary along a straight line and thus in general outside the concave part of a circle. If the polynomial degree of MappingQ is sufficiently high, the transformation from the reference cell to such a cell would in general contain inverted regions close to the boundary.
In order to avoid this situation, this class applies an algorithm for making this transition smooth using a so-called transfinite interpolation that is essentially a linear blend between the descriptions along the surrounding entities. In the algorithm that computes additional points, the compute_mapping_support_points() method, all the entities of the cells are passed through hierarchically, starting from the lines to the quads and finally hexes. Points on objects higher up in the hierarchy are obtained from the manifold associated with that object, taking into account all the points previously computed by the manifolds associated with the lower-dimensional objects, not just the vertices. If only a line is assigned a curved boundary but the adjacent quad is on a flat manifold, the flat manifold on the quad will take the points on the deformed line into account when interpolating the position of the additional points inside the quad and thus always result in a well-defined transformation.
@@ -800,18 +800,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -868,35 +868,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -955,21 +955,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1021,40 +1021,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1365,7 +1365,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1.html 2024-12-27 18:25:06.984861242 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1.html 2024-12-27 18:25:06.992861297 +0000
@@ -729,18 +729,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -795,35 +795,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -880,21 +880,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -944,40 +944,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1314,7 +1314,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
@@ -1376,7 +1376,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1Eulerian.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1Eulerian.html 2024-12-27 18:25:07.064861791 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ1Eulerian.html 2024-12-27 18:25:07.068861819 +0000
@@ -866,18 +866,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -932,35 +932,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -1017,21 +1017,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1081,40 +1081,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1451,7 +1451,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQCache.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQCache.html 2024-12-27 18:25:07.160862450 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQCache.html 2024-12-27 18:25:07.156862423 +0000
@@ -516,7 +516,7 @@
Initialize the data cache by letting the function given as an argument provide the mapping support points for all cells (on all levels) of the given triangulation. The function must return a vector of Point<spacedim> whose length is the same as the size of the polynomial space, , where is the polynomial degree of the mapping, and it must be in the order the mapping or FE_Q sort their points, i.e., all vertex points first, then the points on the lines, quads, and hexes according to the usual hierarchical numbering. No attempt is made to validate these points internally, except for the number of given points.
+
Initialize the data cache by letting the function given as an argument provide the mapping support points for all cells (on all levels) of the given triangulation. The function must return a vector of Point<spacedim> whose length is the same as the size of the polynomial space, , where is the polynomial degree of the mapping, and it must be in the order the mapping or FE_Q sort their points, i.e., all vertex points first, then the points on the lines, quads, and hexes according to the usual hierarchical numbering. No attempt is made to validate these points internally, except for the number of given points.
Note
If multiple threads are enabled, this function will run in parallel, invoking the function passed in several times. Thus, in case MultithreadInfo::n_threads()>1, the user code must make sure that the function, typically a lambda, does not write into data shared with other threads.
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -1153,35 +1153,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -1238,21 +1238,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1302,40 +1302,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1672,7 +1672,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
@@ -1734,7 +1734,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQEulerian.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQEulerian.html 2024-12-27 18:25:07.228862917 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQEulerian.html 2024-12-27 18:25:07.236862972 +0000
@@ -897,18 +897,18 @@
Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field. The mapping kinds currently implemented by derived classes are:
mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
-
+\]" src="form_1367.png"/>
Jacobians of spacedim-vector valued differentiable functions are transformed this way.
In the case when dim=spacedim the previous formula reduces to
-
+\]" src="form_1368.png"/>
@@ -963,35 +963,35 @@
Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_gradient: it assumes so that
- so that
+
+\]" src="form_1370.png"/>
-mapping_covariant_gradient: it assumes so that
- so that
+
+\]" src="form_1372.png"/>
-mapping_piola_gradient: it assumes so that
- so that
+
+\]" src="form_1374.png"/>
@@ -1048,21 +1048,21 @@
The mapping kinds currently implemented by derived classes are:
mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form
Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).
In the case when dim=spacedim the previous formula reduces to
-
+
Parameters
@@ -1112,40 +1112,40 @@
-
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
+
Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of and , with a vector field.
The mapping kinds currently implemented by derived classes are:
-mapping_contravariant_hessian: it assumes so that
- so that
+
+\]" src="form_1382.png"/>
-mapping_covariant_hessian: it assumes so that
- so that
+
+\]" src="form_1384.png"/>
-mapping_piola_hessian: it assumes so that
- so that
+
+\]" src="form_1386.png"/>
@@ -1482,7 +1482,7 @@
Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().
-
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
+
Conceptually, this function's represents the application of the mapping from reference coordinates to real space coordinates for a given cell . Its purpose is to compute the following kinds of data:
Data that results from the application of the mapping itself, e.g., computing the location of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ_1_1InternalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ_1_1InternalData.html 2024-12-27 18:25:07.276863247 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classMappingQ_1_1InternalData.html 2024-12-27 18:25:07.276863247 +0000
@@ -387,7 +387,7 @@
Number of shape functions. If this is a Q1 mapping, then it is simply the number of vertices per cell. However, since also derived classes use this class (e.g. the Mapping_Q() class), the number of shape functions may also be different.
-
In general, it is , where is the polynomial degree of the mapping.
+
In general, it is , where is the polynomial degree of the mapping.
Returns the surface gradient of the shape function with index function_no at the quadrature point with index quadrature_point.
-
The surface gradient is defined as the projection of the gradient to the tangent plane of the surface: , where is the unit normal to the surface.
+
The surface gradient is defined as the projection of the gradient to the tangent plane of the surface: , where is the unit normal to the surface.
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the update_gradients | update_normal_vectors 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 vector-valued, then this returns the only non-zero component. If the shape function has more than one non-zero component (i.e. it is not primitive), then throw an exception of type ExcShapeFunctionNotPrimitive. In that case, use the shape_value_component() function.
Parameters
-
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
+
i
Number of the shape function to be evaluated. Note that this number runs from zero to dofs_per_cell, even in the case of an FEFaceValues or FESubfaceValues object.
q_point
Number of the quadrature point at which function is to be evaluated
@@ -734,7 +734,7 @@
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 non-zero 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.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
component
vector component to be evaluated.
@@ -771,7 +771,7 @@
The same holds for the arguments of this function as for the shape_value() function.
Parameters
-
i
Number of the shape function to be evaluated.
+
i
Number of the shape function to be evaluated.
q_point
Number of the quadrature point at which function is to be evaluated.
@@ -965,11 +965,11 @@
Parameters
[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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the solution vector.
-
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
+
Postcondition
values[q] will contain the value of the field described by fe_function at the th quadrature point.
This function does the same as the other get_function_values(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
+
Postcondition
values[q] is a vector of values of the field described by fe_function at the th quadrature point. The size of the vector accessed by values[q] equals the number of components of the finite element, i.e. values[q](c) returns the value of the th vector component at the th quadrature point.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
+
Postcondition
gradients[q] will contain the gradient of the field described by fe_function at the th quadrature point. gradients[q][d] represents the derivative in coordinate direction at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_gradients(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
gradients[q] is a vector of gradients of the field described by fe_function at the th quadrature point. The size of the vector accessed by gradients[q] equals the number of components of the finite element, i.e. gradients[q][c] returns the gradient of the th vector component at the th quadrature point. Consequently, gradients[q][c][d] is the derivative in coordinate direction of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
+
Postcondition
hessians[q] will contain the Hessian of the field described by fe_function at the th quadrature point. hessians[q][i][j] represents the th component of the matrix of second derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_hessians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
hessians[q] is a vector of Hessians of the field described by fe_function at the th quadrature point. The size of the vector accessed by hessians[q] equals the number of components of the finite element, i.e. hessians[q][c] returns the Hessian of the th vector component at the th quadrature point. Consequently, hessians[q][c][i][j] is the th component of the matrix of second derivatives of the th vector component of the vector field at quadrature point of the current cell.
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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument). This happens to be equal to the type of the elements of the input vector.
-
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
+
Postcondition
laplacians[q] will contain the Laplacian of the field described by fe_function at the th quadrature point.
For each component of the output vector, there holds laplacians[q]=trace(hessians[q]), where hessians would be the output of the get_function_hessians() function.
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
@@ -1489,7 +1489,7 @@
This function does the same as the other get_function_laplacians(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
+
Postcondition
laplacians[q] is a vector of Laplacians of the field described by fe_function at the th quadrature point. The size of the vector accessed by laplacians[q] equals the number of components of the finite element, i.e. laplacians[q][c] returns the Laplacian of the th vector component at the th quadrature point.
For each component of the output vector, there holds laplacians[q][c]=trace(hessians[q][c]), where hessians would be the output of the get_function_hessians() 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 of your finite element vector (represented by the 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 of your finite element vector (represented by the fe_function argument).
-
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
+
Postcondition
third_derivatives[q] will contain the third derivatives of the field described by fe_function at the th quadrature point. third_derivatives[q][i][j][k] represents the th component of the 3rd order tensor of third derivatives at quadrature point .
Note
The actual data type of the input vector may be either a Vector<T>, BlockVector<T>, or one of the PETSc or Trilinos vector wrapper classes. It represents a global vector of DoF values associated with the DoFHandler object with which this FEValues object was last initialized.
This function does the same as the other get_function_third_derivatives(), but applied to multi-component (vector-valued) elements. The meaning of the arguments is as explained there.
-
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
+
Postcondition
third_derivatives[q] is a vector of third derivatives of the field described by fe_function at the th quadrature point. The size of the vector accessed by third_derivatives[q] equals the number of components of the finite element, i.e. third_derivatives[q][c] returns the third derivative of the th vector component at the th quadrature point. Consequently, third_derivatives[q][c][i][j][k] is the th component of the tensor of third derivatives of the th vector component of the vector field at quadrature point of the current cell.
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_pointth 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 in the integral that we implement here by quadrature.
+
You can think of the quantity returned by this function as the volume or surface element in the integral that we implement here by quadrature.
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. .
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2207,7 +2207,7 @@
-
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. .
Note
For this function to work properly, the underlying FEValues, FEFaceValues, or FESubfaceValues object on which you call it must have computed the information you are requesting. To do so, the 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.
@@ -2261,8 +2261,8 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEInterfaceValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEInterfaceValues.html 2024-12-27 18:25:07.596865444 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEInterfaceValues.html 2024-12-27 18:25:07.596865444 +0000
@@ -173,11 +173,11 @@
Detailed Description
template<int dim>
-class NonMatching::FEInterfaceValues< dim >
This class is intended to facilitate assembling interface terms on faces in immersed (in the sense of cut) finite element methods. These types of terms occur mainly in cut discontinuous Galerkin methods. This class works analogously to NonMatching::FEValues. The domain is assumed to be described by a level set function, , and this class assumes that we want to integrate over two different regions of each face, :
-NonMatching::FEValues. The domain is assumed to be described by a level set function, , and this class assumes that we want to integrate over two different regions of each face, :
+
+\]" src="form_2117.png"/>
which we as before refer to as the "inside" and "outside" regions of the face.
To reduce the amount of work, the reinit() function of this class uses the MeshClassifier passed to the constructor to check how the incoming cell relates to the level set function. The immersed quadrature rules are only generated if the cell is intersected. If the cell is completely inside or outside, it returns a cached FEInterfaceValues object created with a quadrature over the reference cell: .
+
To reduce the amount of work, the reinit() function of this class uses the MeshClassifier passed to the constructor to check how the incoming cell relates to the level set function. The immersed quadrature rules are only generated if the cell is intersected. If the cell is completely inside or outside, it returns a cached FEInterfaceValues object created with a quadrature over the reference cell: .
Collection of Quadrature rules over that should be used when a face is not intersected and we do not need to generate immersed quadrature rules.
+
q_collection
Collection of Quadrature rules over that should be used when a face is not intersected and we do not need to generate immersed quadrature rules.
q_collection_1d
Collection of 1-dimensional quadrature rules used to generate the immersed quadrature rules. See the QuadratureGenerator class.
mesh_classifier
Object used to determine when the immersed quadrature rules need to be generated.
region_update_flags
Struct storing UpdateFlags for the inside/outside region of the cell.
@@ -502,7 +502,7 @@
-
Return an FEInterfaceValues object reinitialized with a quadrature for the inside region of the cell: .
+
Return an FEInterfaceValues object reinitialized with a quadrature for the inside region of the cell: .
Note
If the quadrature rule over the region is empty, e.g. because the cell is completely located in the outside domain, the returned optional will not contain a value.
Return an FEInterfaceValues object reinitialized with a quadrature for the outside region of the cell: .
+
Return an FEInterfaceValues object reinitialized with a quadrature for the outside region of the cell: .
Note
If the quadrature rule over the region is empty, e.g. because the cell is completely located in the inside domain, the returned optional will not contain a value.
FEInterfaceValues object created with a quadrature rule integrating over the inside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
+
FEInterfaceValues object created with a quadrature rule integrating over the inside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
FEInterfaceValues object created with a quadrature rule integrating over the outside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
+
FEInterfaceValues object created with a quadrature rule integrating over the outside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEValues.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEValues.html 2024-12-27 18:25:07.632865691 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FEValues.html 2024-12-27 18:25:07.640865746 +0000
@@ -177,17 +177,17 @@
Detailed Description
template<int dim>
-class NonMatching::FEValues< dim >
This class is intended to facilitate assembling in immersed (in the sense of cut) finite element methods when the domain is described by a level set function, . In this type of method, we typically need to integrate over 3 different regions of each cell, :
-. In this type of method, we typically need to integrate over 3 different regions of each cell, :
+
+\]" src="form_2114.png"/>
Thus we need quadrature rules for these 3 regions:
-
As in the QuadratureGenerator class, we refer to , , and as the inside, outside, and surface regions. The constructor of this class takes a discrete level set function described by a DoFHandler and a Vector. When the reinit() function is called, the QuadratureGenerator will be called in the background to create these immersed quadrature rules. This class then creates FEValues objects for the inside/outside regions and an FEImmersedSurfaceValues object for the surface region. These objects can then be accessed through one of the functions: get_inside_fe_values(), get_outside_fe_values(), or get_surface_fe_values(). Since a cut between a cell and the domain can be arbitrarily small, the underlying algorithm may generate a quadrature rule with 0 points. This can, for example, happen if the relative size of the cut is similar to the floating-point accuracy. Since the FEValues-like objects are not allowed to contain 0 points, the object that get_inside/outside/surface_fe_values() returns is wrapped in a std::optional. This requires us to check if the returned FEValues-like object contains a value before we use it:
As in the QuadratureGenerator class, we refer to , , and as the inside, outside, and surface regions. The constructor of this class takes a discrete level set function described by a DoFHandler and a Vector. When the reinit() function is called, the QuadratureGenerator will be called in the background to create these immersed quadrature rules. This class then creates FEValues objects for the inside/outside regions and an FEImmersedSurfaceValues object for the surface region. These objects can then be accessed through one of the functions: get_inside_fe_values(), get_outside_fe_values(), or get_surface_fe_values(). Since a cut between a cell and the domain can be arbitrarily small, the underlying algorithm may generate a quadrature rule with 0 points. This can, for example, happen if the relative size of the cut is similar to the floating-point accuracy. Since the FEValues-like objects are not allowed to contain 0 points, the object that get_inside/outside/surface_fe_values() returns is wrapped in a std::optional. This requires us to check if the returned FEValues-like object contains a value before we use it:
Of course, it is somewhat expensive to generate the immersed quadrature rules and create FEValues objects with the generated quadratures. To reduce the amount of work, the reinit() function of this class uses the MeshClassifier passed to the constructor to check how the incoming cell relates to the level set function. It only generates the immersed quadrature rules if the cell is intersected. If the cell is completely inside or outside, it returns a cached FEValues object created with a quadrature over the reference cell: .
+
Of course, it is somewhat expensive to generate the immersed quadrature rules and create FEValues objects with the generated quadratures. To reduce the amount of work, the reinit() function of this class uses the MeshClassifier passed to the constructor to check how the incoming cell relates to the level set function. It only generates the immersed quadrature rules if the cell is intersected. If the cell is completely inside or outside, it returns a cached FEValues object created with a quadrature over the reference cell: .
Collection of Quadrature rules over that should be used when a cell is not intersected and we do not need to generate immersed quadrature rules.
+
q_collection
Collection of Quadrature rules over that should be used when a cell is not intersected and we do not need to generate immersed quadrature rules.
q_collection_1d
Collection of 1-dimensional quadrature rules used to generate the immersed quadrature rules. See the QuadratureGenerator class.
mesh_classifier
Object used to determine when the immersed quadrature rules need to be generated.
region_update_flags
Struct storing UpdateFlags for the inside/outside/surface region of the cell.
@@ -464,7 +464,7 @@
-
Return an FEValues object reinitialized with a quadrature for the inside region of the cell: .
+
Return an FEValues object reinitialized with a quadrature for the inside region of the cell: .
Note
If the quadrature rule over the region is empty, e.g. because the cell is completely located in the outside domain, the returned optional will not contain a value.
Return an FEValues object reinitialized with a quadrature for the outside region of the cell: .
+
Return an FEValues object reinitialized with a quadrature for the outside region of the cell: .
Note
If the quadrature rule over the region is empty, e.g. because the cell is completely located in the inside domain, the returned optional will not contain a value.
For each element in the FECollection passed to the constructor, this object contains an FEValues object created with a quadrature rule over the full reference cell: and UpdateFlags for the inside region. Thus, these optionals should always contain a value.
+
For each element in the FECollection passed to the constructor, this object contains an FEValues object created with a quadrature rule over the full reference cell: and UpdateFlags for the inside region. Thus, these optionals should always contain a value.
When LocationToLevelSet of the cell is INSIDE (and we do not need to generate an immersed quadrature), we return the FEValues object in this container corresponding to the cell's active_fe_index.
This container is a std::deque, which is compatible with the FEValues class that does not have a copy-constructor.
@@ -829,7 +829,7 @@
-
For each element in the FECollection passed to the constructor, this object contains an FEValues object created with a quadrature rule over the full reference cell: and UpdateFlags for the outside region. Thus, these optionals should always contain a value.
+
For each element in the FECollection passed to the constructor, this object contains an FEValues object created with a quadrature rule over the full reference cell: and UpdateFlags for the outside region. Thus, these optionals should always contain a value.
When LocationToLevelSet of the cell is OUTSIDE (and we do not need to generate an immersed quadrature), we return the FEValues object in this container corresponding to the cell's active_fe_index.
This container is a std::deque, which is compatible with the FEValues class that does not have a copy-constructor.
@@ -858,7 +858,7 @@
-
FEValues object created with a quadrature rule integrating over the inside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
+
FEValues object created with a quadrature rule integrating over the inside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
FEValues object created with a quadrature rule integrating over the outside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
+
FEValues object created with a quadrature rule integrating over the outside region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
FEImmersedSurfaceValues object created with a quadrature rule integrating over the surface region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
+
FEImmersedSurfaceValues object created with a quadrature rule integrating over the surface region, , that was generated in the last call to reinit(..). If the cell in the last call was not intersected or if 0 quadrature points were generated, this optional will not contain a value.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FaceQuadratureGenerator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FaceQuadratureGenerator.html 2024-12-27 18:25:07.664865911 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1FaceQuadratureGenerator.html 2024-12-27 18:25:07.672865966 +0000
@@ -149,16 +149,16 @@
Detailed Description
template<int dim>
-class NonMatching::FaceQuadratureGenerator< dim >
This class creates immersed quadrature rules over a face, , of a BoundingBox, when the domain is described by a level set function, .
-
In the same way as in the QuadratureGenerator class, this class generates quadrature rules to integrate over 3 different regions of the face, :
-, of a BoundingBox, when the domain is described by a level set function, .
+
In the same way as in the QuadratureGenerator class, this class generates quadrature rules to integrate over 3 different regions of the face, :
+
+\]" src="form_2157.png"/>
-
which are again referred to as the "inside", , "outside", , and "surface" region, . These type of quadrature rules are in general needed in immersed discontinuous Galerkin methods.
-
Under the hood, this class uses the QuadratureGenerator class to build these rules. This is done by restricting the dim-dimensional level set function to the face, thus creating a (dim-1)-dimensional level set function, . It then creates the (dim-1)-dimensional quadratures by calling QuadratureGenerator with . This means that what holds for the QuadratureGenerator class in general also holds for this class. In particular, if the 1d-quadrature that is used as base contains points, the number of points will be proportional to in the in the inside/outside quadratures and to in the surface quadrature.
+
which are again referred to as the "inside", , "outside", , and "surface" region, . These type of quadrature rules are in general needed in immersed discontinuous Galerkin methods.
+
Under the hood, this class uses the QuadratureGenerator class to build these rules. This is done by restricting the dim-dimensional level set function to the face, thus creating a (dim-1)-dimensional level set function, . It then creates the (dim-1)-dimensional quadratures by calling QuadratureGenerator with . This means that what holds for the QuadratureGenerator class in general also holds for this class. In particular, if the 1d-quadrature that is used as base contains points, the number of points will be proportional to in the in the inside/outside quadratures and to in the surface quadrature.
This class defines a quadrature formula to integrate over the intersection between an oriented surface, , and a cell or face. The word "immersed" in the class name reflects that the surface may intersect the cell/face in an arbitrary way.
-
The spacedim template parameter of this class is the dimension that the (spacedim-1)-dimensional surface is embedded in: . The dim parameter describes the dimension of the "object" that the surface intersects. That is, dim = spacedim corresponds to the surface intersecting a cell and dim = spacedim - 1 corresponds to the surface intersecting a face. The quadrature formula is described by a set of quadrature points, , weights, , and normalized surface normals, .
-
Consider first the case dim = spacedim. We typically want to compute integrals in real space. A surface, , intersecting a cell, , in real space can be mapped onto a surface, , intersecting the unit cell, . Thus an integral over in real space can be transformed to an integral over according to
-, and a cell or face. The word "immersed" in the class name reflects that the surface may intersect the cell/face in an arbitrary way.
+
The spacedim template parameter of this class is the dimension that the (spacedim-1)-dimensional surface is embedded in: . The dim parameter describes the dimension of the "object" that the surface intersects. That is, dim = spacedim corresponds to the surface intersecting a cell and dim = spacedim - 1 corresponds to the surface intersecting a face. The quadrature formula is described by a set of quadrature points, , weights, , and normalized surface normals, .
+
Consider first the case dim = spacedim. We typically want to compute integrals in real space. A surface, , intersecting a cell, , in real space can be mapped onto a surface, , intersecting the unit cell, . Thus an integral over in real space can be transformed to an integral over according to
+
+\]" src="form_2131.png"/>
-
where is the mapping from reference to real space and is its Jacobian matrix. This transformation is possible since the continuous surface elements are vectors: , which are parallel to the normals of and . That is, the normal is needed to do the transformation. Thus, in addition to storing points and weights, this quadrature stores also the normalized normal for each quadrature point. This can be viewed as storing a discrete surface element,
- is the mapping from reference to real space and is its Jacobian matrix. This transformation is possible since the continuous surface elements are vectors: , which are parallel to the normals of and . That is, the normal is needed to do the transformation. Thus, in addition to storing points and weights, this quadrature stores also the normalized normal for each quadrature point. This can be viewed as storing a discrete surface element,
+
+\]" src="form_2134.png"/>
for each quadrature point. The surface integral in real space would then be approximated as
-
+\]" src="form_2135.png"/>
-
When dim = spacedim - 1, this class represents a (spacedim-2)-dimensional integral. That is, if spacedim = 3 we have a line integral immersed in a face. Let , be an arc-length parameterizations of , i.e., the part of the surface that intersects the face in reference space. This means that is a parameterization of . The transformation of the line integral now reads
-, be an arc-length parameterizations of , i.e., the part of the surface that intersects the face in reference space. This means that is a parameterization of . The transformation of the line integral now reads
+
+\]" src="form_2141.png"/>
-
where is the tangent to the curve at . This tangent can also be computed as where is the face normal. It would be possible to compute the tangent by only knowing the normal to the curve in the face plane (i.e. the dim-dimensional normal). However, when these quadratures are used, the weak form typically involves the so-called conormal, which can not be computed without knowing the surface normal in . The conormal is the unit vector parallel to the projection of the face normal into the surface plane. This is the same as the normalized boundary form.
+
where is the tangent to the curve at . This tangent can also be computed as where is the face normal. It would be possible to compute the tangent by only knowing the normal to the curve in the face plane (i.e. the dim-dimensional normal). However, when these quadratures are used, the weak form typically involves the so-called conormal, which can not be computed without knowing the surface normal in . The conormal is the unit vector parallel to the projection of the face normal into the surface plane. This is the same as the normalized boundary form.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1QuadratureGenerator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1QuadratureGenerator.html 2024-12-27 18:25:07.752866515 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1QuadratureGenerator.html 2024-12-27 18:25:07.756866543 +0000
@@ -147,24 +147,24 @@
Detailed Description
template<int dim>
-class NonMatching::QuadratureGenerator< dim >
This class creates immersed quadrature rules over a BoundingBox, , when the domain is described by a level set function, .
+class NonMatching::QuadratureGenerator< dim >
This class creates immersed quadrature rules over a BoundingBox, , when the domain is described by a level set function, .
This class creates quadrature rules for the intersections between the box and the three different regions defined by the level set function. That is, it creates quadrature rules to integrate over the following regions
-
+\]" src="form_2151.png"/>
-
When working with level set functions, the most common is to describe a domain, , as
-, as
+
+\]" src="form_2152.png"/>
-
Given this, we shall use the name convention that is the "inside" region (i.e. inside ), is the "outside" region and is the "surface" region. The "inside" and "outside" quadratures will also be referred to as the "bulk"-quadratures.
-
The underlying algorithm use a 1-dimensional quadrature rule as base for creating the immersed quadrature rules. Gauss-Legendre quadrature (QGauss) is recommended. The constructor takes an hp::QCollection<1>. One can select which 1d-quadrature in the collection should be used through the set_1d_quadrature() function. The number of quadrature points in the constructed quadratures will vary depending on the level set function. More quadrature points will be created if the intersection is "bad", for example, if the zero-contour has a high curvature compared to the size of the box. However, if the number of points in the 1d quadrature is the number of points will be proportional to in the bulk quadratures and to in the surface quadrature. For example, in the 2d-example in the above figure, there are 2 points in the 1d-quadrature. If the 1d-quadrature is a Gauss-Legendre quadrature and the grid has size , the immersed quadratures typically give global errors proportional to , both for the bulk and surface integrals. If the 1d-quadrature has positive weights, the weights of the immersed quadratures will also be positive.
+
Given this, we shall use the name convention that is the "inside" region (i.e. inside ), is the "outside" region and is the "surface" region. The "inside" and "outside" quadratures will also be referred to as the "bulk"-quadratures.
+
The underlying algorithm use a 1-dimensional quadrature rule as base for creating the immersed quadrature rules. Gauss-Legendre quadrature (QGauss) is recommended. The constructor takes an hp::QCollection<1>. One can select which 1d-quadrature in the collection should be used through the set_1d_quadrature() function. The number of quadrature points in the constructed quadratures will vary depending on the level set function. More quadrature points will be created if the intersection is "bad", for example, if the zero-contour has a high curvature compared to the size of the box. However, if the number of points in the 1d quadrature is the number of points will be proportional to in the bulk quadratures and to in the surface quadrature. For example, in the 2d-example in the above figure, there are 2 points in the 1d-quadrature. If the 1d-quadrature is a Gauss-Legendre quadrature and the grid has size , the immersed quadratures typically give global errors proportional to , both for the bulk and surface integrals. If the 1d-quadrature has positive weights, the weights of the immersed quadratures will also be positive.
A detailed description of the underlying algorithm can be found in "High-Order %Quadrature Methods for Implicitly Defined Surfaces and
Volumes in Hyperrectangles, R. I. Saye, SIAM J. Sci. Comput., 37(2), <a
href="http://www.dx.doi.org/10.1137/140966290">
@@ -305,7 +305,7 @@
-
Return the quadrature rule for the region created in the previous call to generate(). Here, is BoundingBox passed to generate().
+
Return the quadrature rule for the region created in the previous call to generate(). Here, is BoundingBox passed to generate().
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1DiscreteQuadratureGeneratorImplementation_1_1RefSpaceFEFieldFunction.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1DiscreteQuadratureGeneratorImplementation_1_1RefSpaceFEFieldFunction.html 2024-12-27 18:25:07.804866872 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1DiscreteQuadratureGeneratorImplementation_1_1RefSpaceFEFieldFunction.html 2024-12-27 18:25:07.808866900 +0000
@@ -258,7 +258,7 @@
where are the local solution values and are the local reference space shape functions. The gradient and Hessian of this function are thus derivatives with respect to the reference space coordinates, .
Note that this class is similar to FEFieldFunction, but that FEFieldFunction implements the following function on a given cell, ,
,
-
which has the same coefficients but uses real space basis functions. Here, is the mapping from the reference cell to the real cell.
+
which has the same coefficients but uses real space basis functions. Here, is the mapping from the reference cell to the real cell.
Before calling the value/gradient/hessian function, the set_active_cell function must be called to specify which cell the function should be evaluated on.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator.html 2024-12-27 18:25:07.844867147 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator.html 2024-12-27 18:25:07.852867202 +0000
@@ -163,20 +163,20 @@
Detailed Description
template<int dim, int spacedim>
class NonMatching::internal::QuadratureGeneratorImplementation::QGenerator< dim, spacedim >
This class implements the Saye-algorithm cited in the documentation of the QuadratureGenerator class.
-
The generate function takes a number of -dimensional level set functions, , and a BoundingBox<dim>, and builds a partitioning of quadratures, as defined in documentation of the QPartitioning class. That is, this class builds an object of type QPartitioning<dim>.
-
If all passed to generate can be determined to be positive or negative definite, the QPartitioning will consist of a single quadrature forming a tensor product.
-
If this is not the case, the algorithm uses recursion over the spatial dimension. The spacedim template parameter denotes the dimension we started with and dim denotes on what level we are in the recursion. That is, we first construct a QPartitioning<dim - 1> and then build the higher dimensional quadratures from these. What we in the end actually want is a spacedim-dimensional partitioning of quadratures, for a single level set function, .
-
The algorithm is based on the implicit function theorem. Starting with a single level set function, , we try to find a direction , such that
-
.
+
The generate function takes a number of -dimensional level set functions, , and a BoundingBox<dim>, and builds a partitioning of quadratures, as defined in documentation of the QPartitioning class. That is, this class builds an object of type QPartitioning<dim>.
+
If all passed to generate can be determined to be positive or negative definite, the QPartitioning will consist of a single quadrature forming a tensor product.
+
If this is not the case, the algorithm uses recursion over the spatial dimension. The spacedim template parameter denotes the dimension we started with and dim denotes on what level we are in the recursion. That is, we first construct a QPartitioning<dim - 1> and then build the higher dimensional quadratures from these. What we in the end actually want is a spacedim-dimensional partitioning of quadratures, for a single level set function, .
+
The algorithm is based on the implicit function theorem. Starting with a single level set function, , we try to find a direction , such that
+
.
throughout the whole box. This means that the zero-contour of the level set function can be parameterized by an implicit function
-
,
+
,
so that
-
,
-
over a subset, , of the cross section, , of the box (see BoundingBox::cross_section). Here, is the "indefinite"-region defined in the QPartitioning class. To follow convention in the original paper, we will -refer to as the "height-function" and to as the "height-function direction".
-
If a height function direction can be found, we go down in dimension by creating two new level set functions, , which are the restriction of to the top and bottom faces of the box (in the height function direction). We then delegate to QGenerator<dim-1, spacedim> to create a QPartitioning<dim-1> over the cross section.
+
,
+
over a subset, , of the cross section, , of the box (see BoundingBox::cross_section). Here, is the "indefinite"-region defined in the QPartitioning class. To follow convention in the original paper, we will -refer to as the "height-function" and to as the "height-function direction".
+
If a height function direction can be found, we go down in dimension by creating two new level set functions, , which are the restriction of to the top and bottom faces of the box (in the height function direction). We then delegate to QGenerator<dim-1, spacedim> to create a QPartitioning<dim-1> over the cross section.
When we reach the base case, , the creation of QPartitioning<1> is simple. See the documentation in specialized class: QGenerator<1, spacedim>.
As we go up through the dimensions and create the higher dimensional quadratures, we need to know the function value of the height functions at the lower dimensional quadrature points. Since the functions are implicit, we need to do root-finding on the level set functions to find the function values. For this we use the class UpThroughDimensionCreator, see documentation there.
-
When we have level set functions (i.e. after having gone down in dimension), we try to find a height function direction, which works for all those which are intersected by the zero contour (i.e. those not positive or negative definite). If such a direction exist, we will have a maximum of associated implicit height functions, . Each parametrize the -coordinate of the zero-contour over a region, . The indefinite region in the lower dimensional partitioning is the union of these .
+
When we have level set functions (i.e. after having gone down in dimension), we try to find a height function direction, which works for all those which are intersected by the zero contour (i.e. those not positive or negative definite). If such a direction exist, we will have a maximum of associated implicit height functions, . Each parametrize the -coordinate of the zero-contour over a region, . The indefinite region in the lower dimensional partitioning is the union of these .
As we try to find a height function direction, we estimate bounds on the gradient components by approximating each component as a 1st-order Taylor-polynomial. If a direction can not be found, the box is split and we recurse on each smaller box. This makes an implicit function more likely to exist since we seek it over a smaller portion of the zero contour. It also makes the estimated bounds tighter since we extrapolate the Taylor-polynomial a shorter distance.
Since we can not split a box forever, there is an maximum number of allowed splits on the additional data struct passed to the constructor. If this is reached, the algorithm uses the midpoint method as a last resort.
@@ -326,7 +326,7 @@
-
Gets the -dimensional quadratures from the lower dimensional algorithm and creates the -dimensional quadrature rules over the box from the lower dimensional ones.
+
Gets the -dimensional quadratures from the lower dimensional algorithm and creates the -dimensional quadrature rules over the box from the lower dimensional ones.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator_3_011_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:07.880867394 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QGenerator_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:07.888867449 +0000
@@ -164,8 +164,8 @@
Detailed Description
template<int spacedim>
class NonMatching::internal::QuadratureGeneratorImplementation::QGenerator< 1, spacedim >
The 1d-base case of the recursive algorithm QGenerator<dim, spacedim>.
-
Let and be the left and right bounds of the one-dimensional BoundingBox. This interval is partitioned into where , , and the remaining are the roots of the level set functions in the interval . In each interval, , quadrature points are distributed according to a 1d-quadrature rule. These points are added to one of the regions of QPartitioning determined from the signs of the level set functions on the interval (see documentation of QPartitioning).
-
If spacedim = 1 the points are also added as surface quadrature points to QPartitioning::surface.
+
Let and be the left and right bounds of the one-dimensional BoundingBox. This interval is partitioned into where , , and the remaining are the roots of the level set functions in the interval . In each interval, , quadrature points are distributed according to a 1d-quadrature rule. These points are added to one of the regions of QPartitioning determined from the signs of the level set functions on the interval (see documentation of QPartitioning).
+
If spacedim = 1 the points are also added as surface quadrature points to QPartitioning::surface.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QPartitioning.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QPartitioning.html 2024-12-27 18:25:07.912867614 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1QPartitioning.html 2024-12-27 18:25:07.916867641 +0000
@@ -134,19 +134,19 @@
Detailed Description
template<int dim>
-class NonMatching::internal::QuadratureGeneratorImplementation::QPartitioning< dim >
Class that stores quadrature rules to integrate over 4 different regions of a single BoundingBox, . Given multiple level set functions,
-
, ,
-
the box, , is partitioned into a "negative", "positive", and "indefinite" region, , according to the signs of over each region:
+class NonMatching::internal::QuadratureGeneratorImplementation::QPartitioning< dim >
Class that stores quadrature rules to integrate over 4 different regions of a single BoundingBox, . Given multiple level set functions,
+
, ,
+
the box, , is partitioned into a "negative", "positive", and "indefinite" region, , according to the signs of over each region:
-
+\]" src="form_2176.png"/>
-
Thus, all are positive over and negative over . Over the level set functions differ in sign. This class holds quadrature rules for each of these regions. In addition, when there is a single level set function, , it holds a surface quadrature for the zero contour of :
-
.
-
Note that when there is a single level set function, is empty and and are the regions that one typically integrates over in an immersed finite element method.
+
Thus, all are positive over and negative over . Over the level set functions differ in sign. This class holds quadrature rules for each of these regions. In addition, when there is a single level set function, , it holds a surface quadrature for the zero contour of :
+
.
+
Note that when there is a single level set function, is empty and and are the regions that one typically integrates over in an immersed finite element method.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1RootFinder.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1RootFinder.html 2024-12-27 18:25:07.940867806 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1RootFinder.html 2024-12-27 18:25:07.948867861 +0000
@@ -135,7 +135,7 @@
Detailed Description
-
A class that attempts to find multiple distinct roots of a function, , over an interval, . This is done as follows. If there is a sign change in function value between the interval end points, we solve for the root. If there is no sign change, we attempt to bound the function value away from zero on , to conclude that no roots exist. If we can't exclude that there are roots, we split the interval in two: , , and use the same algorithm recursively on each interval. This means that we can typically find 2 distinct roots, but not 3.
+
A class that attempts to find multiple distinct roots of a function, , over an interval, . This is done as follows. If there is a sign change in function value between the interval end points, we solve for the root. If there is no sign change, we attempt to bound the function value away from zero on , to conclude that no roots exist. If we can't exclude that there are roots, we split the interval in two: , , and use the same algorithm recursively on each interval. This means that we can typically find 2 distinct roots, but not 3.
The bounds on the functions values are estimated using the function taylor_estimate_function_bounds, which approximates the function as a second order Taylor-polynomial around the interval midpoint. When we have a sign change on an interval, this class uses boost::math::tools::toms748_solve for finding roots .
For each of the incoming functions, attempt to find the roots over the interval defined by interval and add these to roots. The returned roots will be sorted in ascending order: and duplicate roots (with respect to the tolerance in AdditionalData) will be removed.
+
For each of the incoming functions, attempt to find the roots over the interval defined by interval and add these to roots. The returned roots will be sorted in ascending order: and duplicate roots (with respect to the tolerance in AdditionalData) will be removed.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1UpThroughDimensionCreator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1UpThroughDimensionCreator.html 2024-12-27 18:25:07.972868026 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonMatching_1_1internal_1_1QuadratureGeneratorImplementation_1_1UpThroughDimensionCreator.html 2024-12-27 18:25:07.976868053 +0000
@@ -144,13 +144,13 @@
Detailed Description
template<int dim, int spacedim>
-class NonMatching::internal::QuadratureGeneratorImplementation::UpThroughDimensionCreator< dim, spacedim >
This class is responsible for creating quadrature points for the -dimensional quadrature partitioning from an -dimensional "indefinite" quadrature (see QPartitioning documentation).
-
To be precise, let be the extents of the box in the height function direction and let be the lower dimensional indefinite region. This class will create quadrature points over and in the case , points for the surface quadrature.
-
For each lower dimensional quadrature point, in the indefinite quadrature, we create several 1d-level set functions by restricting to . We then partition the interval into , where , , and the remaining are the roots of the 1d-level set functions in . Since the level set functions change sign between the roots, each interval belong to different regions in the quadrature partitioning.
-
In each interval, , we distribute points according to the 1d-base quadrature, and take the cartesian product with to create the -dimensional quadrature points, : , .
-
When , we have a single level set function, . Since we have fulfilled the implicit function theorem, there is a single root . The point, , will be added as a point in the surface quadrature. One can show that the correct weight of this point is
This class is responsible for creating quadrature points for the -dimensional quadrature partitioning from an -dimensional "indefinite" quadrature (see QPartitioning documentation).
+
To be precise, let be the extents of the box in the height function direction and let be the lower dimensional indefinite region. This class will create quadrature points over and in the case , points for the surface quadrature.
+
For each lower dimensional quadrature point, in the indefinite quadrature, we create several 1d-level set functions by restricting to . We then partition the interval into , where , , and the remaining are the roots of the 1d-level set functions in . Since the level set functions change sign between the roots, each interval belong to different regions in the quadrature partitioning.
+
In each interval, , we distribute points according to the 1d-base quadrature, and take the cartesian product with to create the -dimensional quadrature points, : , .
+
When , we have a single level set function, . Since we have fulfilled the implicit function theorem, there is a single root . The point, , will be added as a point in the surface quadrature. One can show that the correct weight of this point is
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector.html 2024-12-27 18:25:08.004868246 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector.html 2024-12-27 18:25:08.012868301 +0000
@@ -530,11 +530,11 @@
A function object that users may supply and that is intended to prepare the linear solver for subsequent calls to solve_with_jacobian).
The job of setup_jacobian() is to prepare the linear solver for subsequent calls to solve_with_jacobian(), in the solution of linear systems . The exact nature of this system depends on the SolutionStrategy that has been selected.
-
In the cases strategy = SolutionStrategy::newton or SolutionStrategy::linesearch, is the Jacobian . If strategy = SolutionStrategy::picard, is the approximate Jacobian matrix .
+
In the cases strategy = SolutionStrategy::newton or SolutionStrategy::linesearch, is the Jacobian . If strategy = SolutionStrategy::picard, is the approximate Jacobian matrix .
Parameters
-
current_u
Current value of
+
current_u
Current value of
@@ -562,7 +562,7 @@
Parameters
[in]
rhs
The system right hand side to solve for.
-
[out]
dst
The solution of .
+
[out]
dst
The solution of .
[in]
tolerance
The tolerance with which to solve the linear system of equations.
/usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector_1_1AdditionalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector_1_1AdditionalData.html 2024-12-27 18:25:08.040868493 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classNonlinearSolverSelector_1_1AdditionalData.html 2024-12-27 18:25:08.044868520 +0000
@@ -260,7 +260,7 @@
solver_type
Nonlinear solver type.
strategy
Method of solving the nonlinear problem.
maximum_non_linear_iterations
Maximum number of nonlinear iterations.
-
function_tolerance
Absolute stopping tolerance for the norm of the residual .
+
function_tolerance
Absolute stopping tolerance for the norm of the residual .
relative_tolerance
Relative stopping tolerance.
step_tolerance
Tolerance for minimum scaled step length
anderson_subspace_size
Size of the Anderson acceleration subspace, use 0 to disable.
@@ -343,7 +343,7 @@
-
A scalar used as a stopping tolerance on the scaled maximum norm of the system function or .
+
A scalar used as a stopping tolerance on the scaled maximum norm of the system function or .
/usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1ArclengthProjectionLineManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1ArclengthProjectionLineManifold.html 2024-12-27 18:25:08.084868795 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1ArclengthProjectionLineManifold.html 2024-12-27 18:25:08.088868822 +0000
@@ -573,7 +573,7 @@
-
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -603,24 +603,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1DirectionalProjectionManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1DirectionalProjectionManifold.html 2024-12-27 18:25:08.132869125 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1DirectionalProjectionManifold.html 2024-12-27 18:25:08.136869152 +0000
@@ -487,7 +487,7 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
+
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
Note
If you use this class as a stepping stone to build a manifold that only "slightly" deviates from a flat manifold, by overloading the project_to_manifold() function.
Parameters
@@ -496,7 +496,7 @@
-
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
+
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
/usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NURBSPatchManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NURBSPatchManifold.html 2024-12-27 18:25:08.180869454 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NURBSPatchManifold.html 2024-12-27 18:25:08.184869482 +0000
@@ -448,7 +448,7 @@
-
Given a point in the spacedim dimensional Euclidean space, this method returns the derivatives of the function that maps from the uv coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
+
Given a point in the spacedim dimensional Euclidean space, this method returns the derivatives of the function that maps from the uv coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
This function is used in the computations required by the get_tangent_vector() function.
Refer to the general documentation of this class for more information.
@@ -637,7 +637,7 @@
-
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -667,24 +667,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalProjectionManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalProjectionManifold.html 2024-12-27 18:25:08.224869756 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalProjectionManifold.html 2024-12-27 18:25:08.228869784 +0000
@@ -481,7 +481,7 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
+
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
Note
If you use this class as a stepping stone to build a manifold that only "slightly" deviates from a flat manifold, by overloading the project_to_manifold() function.
Parameters
@@ -490,7 +490,7 @@
-
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
+
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
/usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalToMeshProjectionManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalToMeshProjectionManifold.html 2024-12-27 18:25:08.272870086 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classOpenCASCADE_1_1NormalToMeshProjectionManifold.html 2024-12-27 18:25:08.276870113 +0000
@@ -481,7 +481,7 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
+
Return a vector that, at , is tangential to the geodesic that connects two points . For the current class, we assume that the manifold is flat, so the geodesic is the straight line between the two points, and we return . The normalization of the vector is chosen so that it fits the convention described in Manifold::get_tangent_vector().
Note
If you use this class as a stepping stone to build a manifold that only "slightly" deviates from a flat manifold, by overloading the project_to_manifold() function.
Parameters
@@ -490,7 +490,7 @@
-
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
+
Returns
A "direction" vector tangential to the geodesic. Here, this is , possibly modified by the periodicity of the domain as set in the constructor, to use the "shortest" connection between the points through the periodic boundary as necessary.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPArpackSolver.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPArpackSolver.html 2024-12-27 18:25:08.320870415 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPArpackSolver.html 2024-12-27 18:25:08.324870443 +0000
@@ -286,7 +286,7 @@
Detailed Description
template<typename VectorType>
class PArpackSolver< VectorType >
Interface for using PARPACK. PARPACK is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. Here we interface to the routines pdneupd, pdseupd, pdnaupd, pdsaupd of PARPACK. 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 , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively.
+
In this class we make use of the method applied to the generalized eigenspectrum problem , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively.
The ArpackSolver can be used in application codes in the following way:
for the generalized eigenvalue problem , where the variable size_of_spectrum tells PARPACK the number of eigenvector/eigenvalue pairs to solve for. Here, lambda is a vector that will contain the eigenvalues computed, x a vector of objects of type V that will contain the eigenvectors computed.
-
Currently, only three modes of (P)Arpack are implemented. In mode 3 (default), OP is an inverse operation for the matrix A - sigma * B, where sigma is a shift value, set to zero by default. Whereas in mode 2, OP is an inverse of M. Finally, mode 1 corresponds to standard eigenvalue problem without spectral transformation . The mode can be specified via AdditionalData object. Note that for shift-and-invert (mode=3), the sought eigenpairs are those after the spectral transformation is applied.
+
for the generalized eigenvalue problem , where the variable size_of_spectrum tells PARPACK the number of eigenvector/eigenvalue pairs to solve for. Here, lambda is a vector that will contain the eigenvalues computed, x a vector of objects of type V that will contain the eigenvectors computed.
+
Currently, only three modes of (P)Arpack are implemented. In mode 3 (default), OP is an inverse operation for the matrix A - sigma * B, where sigma is a shift value, set to zero by default. Whereas in mode 2, OP is an inverse of M. Finally, mode 1 corresponds to standard eigenvalue problem without spectral transformation . The mode can be specified via AdditionalData object. Note that for shift-and-invert (mode=3), the sought eigenpairs are those after the spectral transformation is applied.
Reinitialization that takes the number of locally-owned degrees of freedom local_size and an index set for the required ghost indices ghost_indices.
-
The local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively.
+
The local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively.
The export_to_ghost_array will populate an array containing values from locally-owned AND ghost indices, as for the relevant set of dofs of a usual FEM simulation.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1FullMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1FullMatrix.html 2024-12-27 18:25:08.416871075 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1FullMatrix.html 2024-12-27 18:25:08.420871103 +0000
@@ -1518,8 +1518,8 @@
-
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.
@@ -2351,7 +2351,7 @@
Base function to perform the matrix-matrix multiplication , or, if a vector whose size is compatible with B is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be reset by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be changed by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Adding Matrix-vector multiplication. Add on with being this matrix.
+
Adding Matrix-vector multiplication. Add on with being this matrix.
@@ -2624,7 +2624,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Due to problems with deriving template arguments between the block and non-block 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.
@@ -2732,7 +2732,7 @@
-
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
+
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1BlockVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1BlockVector.html 2024-12-27 18:25:08.576872174 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1BlockVector.html 2024-12-27 18:25:08.580872201 +0000
@@ -1956,7 +1956,7 @@
-
: scalar product.
+
: scalar product.
@@ -1982,7 +1982,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
@@ -2034,7 +2034,7 @@
-
Return the -norm of the vector, i.e. the sum of the absolute values.
+
Return the -norm of the vector, i.e. the sum of the absolute values.
@@ -2060,7 +2060,7 @@
-
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
+
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
@@ -2086,7 +2086,7 @@
-
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
+
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2368,7 +2368,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1SparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1SparseMatrix.html 2024-12-27 18:25:08.652872696 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MPI_1_1SparseMatrix.html 2024-12-27 18:25:08.656872723 +0000
@@ -827,7 +827,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.
@@ -2905,7 +2905,7 @@
Base function to perform the matrix-matrix multiplication , or, if a vector whose size is compatible with B is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be reset by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be changed by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
-norm of the vector. The sum of the absolute values.
+
-norm of the vector. The sum of the absolute values.
Note
In complex-valued PETSc priori to 3.7.0 this norm is implemented as the sum of absolute values of real and imaginary parts of elements of a complex vector.
The reason this function exists is for compatibility with deal.II's own vector classes which can implement this functionality with less memory transfer. However, for PETSc vectors such a combined operation is not natively supported and thus the cost is completely equivalent as calling the two methods separately.
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixBase.html 2024-12-27 18:25:08.784873602 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixBase.html 2024-12-27 18:25:08.788873630 +0000
@@ -1303,8 +1303,8 @@
-
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.
@@ -1972,7 +1972,7 @@
Base function to perform the matrix-matrix multiplication , or, if a vector whose size is compatible with B is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be reset by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be changed by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixFree.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixFree.html 2024-12-27 18:25:08.864874151 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1MatrixFree.html 2024-12-27 18:25:08.868874179 +0000
@@ -1962,8 +1962,8 @@
-
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.
@@ -2675,7 +2675,7 @@
Base function to perform the matrix-matrix multiplication , or, if a vector whose size is compatible with B is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be reset by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be changed by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1NonlinearSolver.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1NonlinearSolver.html 2024-12-27 18:25:08.900874399 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1NonlinearSolver.html 2024-12-27 18:25:08.904874426 +0000
@@ -194,7 +194,7 @@
Mat & petsc_matrix();
...
In particular, the supported types are the ones that can wrap PETSc's native vector and matrix classes, that are able to modify them in place, and that can return PETSc native types when requested.
-
To use the solvers the user needs to provide the implementation of via the NonlinearSolver::residual callback.
+
To use the solvers the user needs to provide the implementation of via the NonlinearSolver::residual callback.
The default linearization procedure of a solver instantiated with this class consists in using Jacobian-Free-Newton-Krylov; the action of tangent matrices inside a linear solver process are approximated via matrix-free finite-differencing of the nonlinear residual equations. For details, consult the PETSc manual.
Users can also provide the implementations of the Jacobian. This can be accomplished in two ways:
/usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1SparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1SparseMatrix.html 2024-12-27 18:25:08.972874893 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPETScWrappers_1_1SparseMatrix.html 2024-12-27 18:25:08.980874948 +0000
@@ -1952,8 +1952,8 @@
-
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the l1-norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the linfty-norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Note that if the current object represents a parallel distributed matrix (of type PETScWrappers::MPI::SparseMatrix), then the given vector has to be a distributed vector as well. Conversely, if the matrix is not distributed, then neither may the vector be.
@@ -2785,7 +2785,7 @@
Base function to perform the matrix-matrix multiplication , or, if a vector whose size is compatible with B is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be reset by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
-
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
+
Base function to perform the matrix-matrix multiplication with the transpose of this, i.e., , or, if an optional vector whose size is compatible with is given, , where defines a diagonal matrix with the vector entries.
+
This function assumes that the calling matrix and have compatible sizes. The size of will be set within this function.
The content as well as the sparsity pattern of the matrix will be changed by this function, so make sure that the sparsity pattern is not used somewhere else in your program. This is an expensive operation, so think twice before you use this function.
Interface to the PETSc TS solver for Ordinary Differential Equations and Differential-Algebraic Equations. The TS solver is described in the PETSc manual. This class is used and extensively discussed in step-86.
This class supports two kinds of formulations. The explicit formulation:
-
+ \]" src="form_1821.png"/>
and the implicit formulation:
-
+ \]" src="form_1822.png"/>
The interface to PETSc is realized by means of std::function callbacks like in the SUNDIALS::IDA (which also solves implicit ODES) and SUNDIALS::ARKode classes (which solves a slightly generalized form of the explicit formulation above that also allows for a mass matrix on the left hand side).
TimeStepper supports any vector and matrix type having constructors and methods:
@@ -247,7 +247,7 @@
Mat & petsc_matrix();
...
In particular, the supported types are the ones that can wrap PETSc's native vector and matrix classes, that are able to modify them in place, and that can return PETSc native types when requested.
-
To use explicit solvers (like for example explicit Runge-Kutta methods), the user only needs to provide the implementation of via the TimeStepper::explicit_function. For implicit solvers, users have also the alternative of providing the function via TimeStepper::implicit_function. IMEX methods are also supported by providing both callbacks.
+
To use explicit solvers (like for example explicit Runge-Kutta methods), the user only needs to provide the implementation of via the TimeStepper::explicit_function. For implicit solvers, users have also the alternative of providing the function via TimeStepper::implicit_function. IMEX methods are also supported by providing both callbacks.
The default linearization procedure of an implicit solver instantiated with this class consists in using Jacobian-Free-Newton-Krylov; the action of tangent matrices inside a linear solver process are approximated via matrix-free finite-differencing of the nonlinear residual equations that are ODE-solver specific. For details, consult the PETSc manual.
Users can also provide the implementations of the Jacobians. This can be accomplished in two ways:
-norm of the vector. The sum of the absolute values.
+
-norm of the vector. The sum of the absolute values.
Note
In complex-valued PETSc priori to 3.7.0 this norm is implemented as the sum of absolute values of real and imaginary parts of elements of a complex vector.
The reason this function exists is for compatibility with deal.II's own vector classes which can implement this functionality with less memory transfer. However, for PETSc vectors such a combined operation is not natively supported and thus the cost is completely equivalent as calling the two methods separately.
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
Insert a particle into the collection of particles. Return an iterator to the new position of the particle. This function involves a copy of the particle and its properties. Note that this function is of complexity for particles.
+N)$" src="form_2511.png"/> complexity for particles.
/usr/share/doc/packages/dealii/doxygen/deal.II/classParticles_1_1PropertyPool.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classParticles_1_1PropertyPool.html 2024-12-27 18:25:09.284877035 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classParticles_1_1PropertyPool.html 2024-12-27 18:25:09.292877090 +0000
@@ -677,7 +677,7 @@
-
This function makes sure that all internally stored memory blocks are sorted in the same order as one would loop over the handles_to_sort container. This makes sure memory access is contiguous with actual memory location. Because the ordering is given in the input argument the complexity of this function is where is the number of elements in the input argument.
+
This function makes sure that all internally stored memory blocks are sorted in the same order as one would loop over the handles_to_sort container. This makes sure memory access is contiguous with actual memory location. Because the ordering is given in the input argument the complexity of this function is where is the number of elements in the input argument.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPersistentTriangulation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPersistentTriangulation.html 2024-12-27 18:25:09.468878299 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPersistentTriangulation.html 2024-12-27 18:25:09.472878326 +0000
@@ -2225,7 +2225,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -6947,7 +6947,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPoint.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPoint.html 2024-12-27 18:25:09.536878766 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPoint.html 2024-12-27 18:25:09.540878793 +0000
@@ -879,7 +879,7 @@
-
Return the Euclidean distance of this point to the point p, i.e. the norm of the difference between the vectors representing the two points.
+
Return the Euclidean distance of this point to the point p, i.e. the norm of the difference between the vectors representing the two points.
The dot product (single contraction) for tensors. This function return a tensor of rank that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
- that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
+
+\]" src="form_863.png"/>
Note
For the Tensor class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for SymmetricTensor, for which the corresponding operator*() performs a double contraction. The origin of the difference in how operator*() is implemented between Tensor and SymmetricTensor is that for the former, the product between two Tensor objects of same rank and dimension results in another Tensor object – that it, operator*() corresponds to the multiplicative group action within the group of tensors. On the other hand, there is no corresponding multiplicative group action with the set of symmetric tensors because, in general, the product of two symmetric tensors is a nonsymmetric tensor. As a consequence, for a mathematician, it is clear that operator*() for symmetric tensors must have a different meaning: namely the dot or scalar product that maps two symmetric tensors of rank 2 to a scalar. This corresponds to the double-dot (colon) operator whose meaning is then extended to the product of any two even-ranked symmetric tensors.
-In case the contraction yields a tensor of rank 0, that is, if rank_1==rank_2==1, then a scalar number is returned as an unwrapped number type. Return the norm of the given rank-2 tensor, where (maximum of the sums over columns).
+In case the contraction yields a tensor of rank 0, that is, if rank_1==rank_2==1, then a scalar number is returned as an unwrapped number type. Return the norm of the given rank-2 tensor, where (maximum of the sums over columns).
/usr/share/doc/packages/dealii/doxygen/deal.II/classPolarManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPolarManifold.html 2024-12-27 18:25:09.584879095 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPolarManifold.html 2024-12-27 18:25:09.592879150 +0000
@@ -458,7 +458,7 @@
-
Given a point in the spacedim dimensional Euclidean space, this method returns the derivatives of the function that maps from the polar coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
+
Given a point in the spacedim dimensional Euclidean space, this method returns the derivatives of the function that maps from the polar coordinate system to the Euclidean coordinate system. In other words, it is a matrix of size .
This function is used in the computations required by the get_tangent_vector() function.
Refer to the general documentation of this class for more information.
@@ -716,7 +716,7 @@
-
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -748,24 +748,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernardiRaugel.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernardiRaugel.html 2024-12-27 18:25:09.620879343 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernardiRaugel.html 2024-12-27 18:25:09.628879397 +0000
@@ -156,7 +156,7 @@
template<int dim>
class PolynomialsBernardiRaugel< dim >
This class implements the Bernardi-Raugel polynomials similarly to the description in the Mathematics of Computation paper from 1985 by Christine Bernardi and Geneviève Raugel.
The Bernardi-Raugel polynomials are originally defined as an enrichment of the elements on simplicial meshes for Stokes problems by the addition of bubble functions, yielding a locking-free finite element which is a subset of elements. This implementation is an enrichment of elements which is a subset of elements for quadrilateral and hexahedral meshes.
-
The bubble functions are defined to have magnitude 1 at the center of face and direction normal to face , and magnitude 0 on all other vertices and faces. Ordering is consistent with the face numbering in GeometryInfo. The vector points in the positive axis direction and not necessarily normal to the element for consistent orientation across edges.
+
The bubble functions are defined to have magnitude 1 at the center of face and direction normal to face , and magnitude 0 on all other vertices and faces. Ordering is consistent with the face numbering in GeometryInfo. The vector points in the positive axis direction and not necessarily normal to the element for consistent orientation across edges.
2d bubble functions (in order)
edge:
@f$x=1@f$ edge: @f$\mathbf{p}_2 = \mathbf{n}_2 (x)(y)(1-y)@f$
/usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernstein.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernstein.html 2024-12-27 18:25:09.664879645 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsBernstein.html 2024-12-27 18:25:09.664879645 +0000
@@ -1245,7 +1245,7 @@
-
If the polynomial is in Lagrange product form, i.e., constructed as a product , store the shifts .
+
If the polynomial is in Lagrange product form, i.e., constructed as a product , store the shifts .
/usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsRT__Bubbles.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsRT__Bubbles.html 2024-12-27 18:25:09.700879892 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomialsRT__Bubbles.html 2024-12-27 18:25:09.700879892 +0000
@@ -152,18 +152,18 @@
This space is of the form Vk = RTk-1 + Bk, where Bk is defined as follows:
In 2d:
-
+\end{align*}" src="form_718.png"/>
In 3d:
-
+ \end{align*}" src="form_719.png"/>
-
where .
+
where .
Note
Unlike the classical Raviart-Thomas space, the lowest order for the enhanced space is 1, similarly to the Brezzi-Douglas-Marini (BDM) polynomial space.
The total dimension of the space dim(Vk) = d*(k+1)^d, where d is the space dimension. This allows to associate shape functions with the Gauss-Lobatto quadrature points as shown in the figures below.
These polynomials are the integrated Legendre polynomials on [0,1]. The first two polynomials are the standard linear shape functions given by and . For we use the definition , where denotes the -th Legendre polynomial on . The Lobatto polynomials form a complete basis of the polynomials space of degree .
+
These polynomials are the integrated Legendre polynomials on [0,1]. The first two polynomials are the standard linear shape functions given by and . For we use the definition , where denotes the -th Legendre polynomial on . The Lobatto polynomials form a complete basis of the polynomials space of degree .
Calling the constructor with a given index k will generate the polynomial with index k. But only for the index equals the degree of the polynomial. For k==0 also a polynomial of degree 1 is generated.
These polynomials are used for the construction of the shape functions of Nédélec elements of arbitrary order.
@@ -1217,7 +1217,7 @@
-
If the polynomial is in Lagrange product form, i.e., constructed as a product , store the shifts .
+
If the polynomial is in Lagrange product form, i.e., constructed as a product , store the shifts .
/usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomials_1_1PolynomialsHermite.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomials_1_1PolynomialsHermite.html 2024-12-27 18:25:10.116882748 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classPolynomials_1_1PolynomialsHermite.html 2024-12-27 18:25:10.120882776 +0000
@@ -1210,7 +1210,7 @@
-
The order of the highest derivative in which the Hermite basis can be used to impose continuity across element boundaries. It's related to the degree by .
+
The order of the highest derivative in which the Hermite basis can be used to impose continuity across element boundaries. It's related to the degree by .
/usr/share/doc/packages/dealii/doxygen/deal.II/classQDuffy.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQDuffy.html 2024-12-27 18:25:10.188883243 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQDuffy.html 2024-12-27 18:25:10.196883298 +0000
@@ -234,8 +234,8 @@
x = v_0 + B \hat x
\]" src="form_783.png"/>
-
where the matrix is given by .
-
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
+
where the matrix is given by .
+
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
Parameters
[in]
vertices
The vertices of the simplex you wish to integrate on
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussChebyshev.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussChebyshev.html 2024-12-27 18:25:10.220883462 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussChebyshev.html 2024-12-27 18:25:10.220883462 +0000
@@ -122,7 +122,7 @@
Gauss-Chebyshev quadrature rules integrate the weighted product with weight given by: . The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: with weight given by: . The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: . For details see: M. Abramowitz & I.A. Stegun: Handbook of Mathematical Functions, par. 25.4.38
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLobatto.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLobatto.html 2024-12-27 18:25:10.240883600 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLobatto.html 2024-12-27 18:25:10.244883627 +0000
@@ -123,7 +123,7 @@
class QGaussLobatto< dim >
The Gauss-Lobatto family of quadrature rules for numerical integration.
This modification of the Gauss quadrature uses the two interval end points as well. Being exact for polynomials of degree 2n-3, this formula is suboptimal by two degrees.
The quadrature points are interval end points plus the roots of the derivative of the Legendre polynomial Pn-1 of degree n-1. The quadrature weights are 2/(n(n-1)(Pn-1(xi)2).
-
Note
This implementation has not been optimized concerning numerical stability and efficiency. It can be easily adapted to the general case of Gauss-Lobatto-Jacobi-Bouzitat quadrature with arbitrary parameters , , of which the Gauss-Lobatto-Legendre quadrature (
Note
This implementation has not been optimized concerning numerical stability and efficiency. It can be easily adapted to the general case of Gauss-Lobatto-Jacobi-Bouzitat quadrature with arbitrary parameters , , of which the Gauss-Lobatto-Legendre quadrature ( ) is a special case.
template<int dim>
-class QGaussLobattoChebyshev< dim >
Gauss-Lobatto-Chebyshev quadrature rules integrate the weighted product with weight given by: , with the additional constraint that two of the quadrature points are located at the endpoints of the quadrature interval. The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: . For details see: M. Abramowitz & I.A. Stegun: Handbook of Mathematical Functions, par. 25.4.40
+class QGaussLobattoChebyshev< dim >
Gauss-Lobatto-Chebyshev quadrature rules integrate the weighted product with weight given by: , with the additional constraint that two of the quadrature points are located at the endpoints of the quadrature interval. The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: . For details see: M. Abramowitz & I.A. Stegun: Handbook of Mathematical Functions, par. 25.4.40
A class for Gauss quadrature with logarithmic weighting function. This formula is used to integrate on the interval , where is a smooth function without singularities. The collection of quadrature points and weights has been obtained using Numerical Recipes.
-
Notice that only the function should be provided, i.e., on the interval , where is a smooth function without singularities. The collection of quadrature points and weights has been obtained using Numerical Recipes.
+
Notice that only the function should be provided, i.e., . Setting the revert flag to true at construction time switches the weight from to .
The weights and functions have been tabulated up to order 12.
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLogR.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLogR.html 2024-12-27 18:25:10.320884149 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussLogR.html 2024-12-27 18:25:10.324884177 +0000
@@ -128,15 +128,15 @@
A class for Gauss quadrature with arbitrary logarithmic weighting function. This formula is used to integrate on the interval , where is a smooth function without singularities, and and are given at construction time, and are the location of the singularity and an arbitrary scaling factor in the singularity.
-
You have to make sure that the point is not one of the Gauss quadrature points of order , otherwise an exception is thrown, since the quadrature weights cannot be computed correctly.
+class QGaussLogR< dim >
A class for Gauss quadrature with arbitrary logarithmic weighting function. This formula is used to integrate on the interval , where is a smooth function without singularities, and and are given at construction time, and are the location of the singularity and an arbitrary scaling factor in the singularity.
+
You have to make sure that the point is not one of the Gauss quadrature points of order , otherwise an exception is thrown, since the quadrature weights cannot be computed correctly.
This quadrature formula is rather expensive, since it uses internally two Gauss quadrature formulas of order n to integrate the nonsingular part of the factor, and two GaussLog quadrature formulas to integrate on the separate segments and . If the singularity is one of the extremes and the factor alpha is 1, then this quadrature is the same as QGaussLog.
The last argument from the constructor allows you to use this quadrature rule in one of two possible ways:
-
Which one of the two sets of weights is provided, can be selected by the factor_out_singular_weight parameter. If it is false (the default), then the weights are computed, and you should provide only the smooth function , since the singularity is included inside the quadrature. If the parameter is set to true, then the singularity is factored out of the quadrature formula, and you should provide a function , which should at least be similar to .
+
Which one of the two sets of weights is provided, can be selected by the factor_out_singular_weight parameter. If it is false (the default), then the weights are computed, and you should provide only the smooth function , since the singularity is included inside the quadrature. If the parameter is set to true, then the singularity is factored out of the quadrature formula, and you should provide a function , which should at least be similar to .
Notice that this quadrature rule is worthless if you try to use it for regular functions once you factored out the singularity.
The weights and functions have been tabulated up to order 12.
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussOneOverR.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussOneOverR.html 2024-12-27 18:25:10.356884396 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussOneOverR.html 2024-12-27 18:25:10.364884451 +0000
@@ -132,9 +132,9 @@
static unsigned int&#href_anchor"memItemRight" valign="bottom">quad_size (const Point< dim > &singularity, const unsigned int n)
A class for Gauss quadrature with weighting function. This formula can be used to integrate on the reference element , where is a smooth function without singularities, and is the distance from the point to the vertex , given at construction time by specifying its index. Notice that this distance is evaluated in the reference element.
-
This quadrature formula is obtained from two QGauss quadrature formulas, upon transforming them into polar coordinate system centered at the singularity, and then again into another reference element. This allows for the singularity to be cancelled by part of the Jacobian of the transformation, which contains . In practice the reference element is transformed into a triangle by collapsing one of the sides adjacent to the singularity. The Jacobian of this transformation contains , which is removed before scaling the original quadrature, and this process is repeated for the next half element.
-
Upon construction it is possible to specify whether we want the singularity removed, or not. In other words, this quadrature can be used to integrate , or simply , with the factor already included in the quadrature weights.
+class QGaussOneOverR< dim >
A class for Gauss quadrature with weighting function. This formula can be used to integrate on the reference element , where is a smooth function without singularities, and is the distance from the point to the vertex , given at construction time by specifying its index. Notice that this distance is evaluated in the reference element.
+
This quadrature formula is obtained from two QGauss quadrature formulas, upon transforming them into polar coordinate system centered at the singularity, and then again into another reference element. This allows for the singularity to be cancelled by part of the Jacobian of the transformation, which contains . In practice the reference element is transformed into a triangle by collapsing one of the sides adjacent to the singularity. The Jacobian of this transformation contains , which is removed before scaling the original quadrature, and this process is repeated for the next half element.
+
Upon construction it is possible to specify whether we want the singularity removed, or not. In other words, this quadrature can be used to integrate , or simply , with the factor already included in the quadrature weights.
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussRadauChebyshev.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussRadauChebyshev.html 2024-12-27 18:25:10.388884616 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussRadauChebyshev.html 2024-12-27 18:25:10.392884643 +0000
@@ -139,7 +139,7 @@
Detailed Description
template<int dim>
-class QGaussRadauChebyshev< dim >
Gauss-Radau-Chebyshev quadrature rules integrate the weighted product with weight given by: with the additional constraint that a quadrature point lies at one of the two extrema of the interval. The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: . By default the quadrature is constructed with the left endpoint as quadrature node, but the quadrature node can be imposed at the right endpoint through the variable ep that can assume the values left or right.
+class QGaussRadauChebyshev< dim >
Gauss-Radau-Chebyshev quadrature rules integrate the weighted product with weight given by: with the additional constraint that a quadrature point lies at one of the two extrema of the interval. The nodes and weights are known analytically, and are exact for monomials up to the order , where is the number of quadrature points. Here we rescale the quadrature formula so that it is defined on the interval instead of . So the quadrature formulas integrate exactly the integral with the weight: . By default the quadrature is constructed with the left endpoint as quadrature node, but the quadrature node can be imposed at the right endpoint through the variable ep that can assume the values left or right.
/usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussSimplex.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussSimplex.html 2024-12-27 18:25:10.424884863 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQGaussSimplex.html 2024-12-27 18:25:10.424884863 +0000
@@ -200,8 +200,8 @@
x = v_0 + B \hat x
\]" src="form_783.png"/>
-
where the matrix is given by .
-
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
+
where the matrix is given by .
+
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
Parameters
[in]
vertices
The vertices of the simplex you wish to integrate on
/usr/share/doc/packages/dealii/doxygen/deal.II/classQR.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQR.html 2024-12-27 18:25:10.452885056 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQR.html 2024-12-27 18:25:10.456885084 +0000
@@ -315,7 +315,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classQSimplex.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQSimplex.html 2024-12-27 18:25:10.480885248 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQSimplex.html 2024-12-27 18:25:10.480885248 +0000
@@ -186,8 +186,8 @@
x = v_0 + B \hat x
\]" src="form_783.png"/>
-
where the matrix is given by .
-
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
+
where the matrix is given by .
+
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
Parameters
[in]
vertices
The vertices of the simplex you wish to integrate on
/usr/share/doc/packages/dealii/doxygen/deal.II/classQTelles.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQTelles.html 2024-12-27 18:25:10.512885468 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQTelles.html 2024-12-27 18:25:10.512885468 +0000
@@ -148,7 +148,7 @@
\end{align*}" src="form_762.png"/>
Since the library assumes as reference interval, we will map these values on the proper reference interval in the implementation.
-
This variable change can be used to integrate singular integrals. One example is on the reference interval , where is given at construction time, and is the location of the singularity , and is a smooth non singular function.
+
This variable change can be used to integrate singular integrals. One example is on the reference interval , where is given at construction time, and is the location of the singularity , and is a smooth non singular function.
Singular quadrature formula are rather expensive, nevertheless Telles' quadrature formula are much easier to compute with respect to other singular integration techniques as Lachat-Watson.
We have implemented the case for . When we deal the case we have computed the quadrature formula has a tensorial product of one dimensional Telles' quadrature formulas considering the different components of the singularity.
The weights and functions for Gauss Legendre formula have been tabulated up to order 12.
/usr/share/doc/packages/dealii/doxygen/deal.II/classQTrianglePolar.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQTrianglePolar.html 2024-12-27 18:25:10.532885605 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQTrianglePolar.html 2024-12-27 18:25:10.540885660 +0000
@@ -223,8 +223,8 @@
x = v_0 + B \hat x
\]" src="form_783.png"/>
-
where the matrix is given by .
-
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
+
where the matrix is given by .
+
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
Parameters
[in]
vertices
The vertices of the simplex you wish to integrate on
/usr/share/doc/packages/dealii/doxygen/deal.II/classQWitherdenVincentSimplex.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQWitherdenVincentSimplex.html 2024-12-27 18:25:10.560885798 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQWitherdenVincentSimplex.html 2024-12-27 18:25:10.564885825 +0000
@@ -124,7 +124,7 @@
&#href_anchor"details" id="details">
Detailed Description
template<int dim>
class QWitherdenVincentSimplex< dim >
Witherden-Vincent rules for simplex entities.
-
Like QGauss, users should specify a number n_points_1d as an indication of what polynomial degree to be integrated exactly (e.g., for points, the rule can integrate polynomials of degree exactly). Additionally, since these rules were derived for simplices, there are also even-ordered rules (i.e., they integrate polynomials of degree ) available which do not have analogous 1d rules.
+
Like QGauss, users should specify a number n_points_1d as an indication of what polynomial degree to be integrated exactly (e.g., for points, the rule can integrate polynomials of degree exactly). Additionally, since these rules were derived for simplices, there are also even-ordered rules (i.e., they integrate polynomials of degree ) available which do not have analogous 1d rules.
The given value for n_points_1d = 1, 2, 3, 4, 5, 6, 7 (where the last two are only implemented in 2d) results in the following number of quadrature points in 2d and 3d:
2d: odd (default): 1, 6, 7, 15, 19, 28, 37
2d: even: 3, 6, 12, 16, 25, 33, 42
@@ -202,8 +202,8 @@
x = v_0 + B \hat x
\]" src="form_783.png"/>
-
where the matrix is given by .
-
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
+
where the matrix is given by .
+
The weights are scaled with the absolute value of the determinant of , that is . If is zero, an empty quadrature is returned. This may happen, in two dimensions, if the three vertices are aligned, or in three dimensions if the four vertices are on the same plane. The present function works also in the codimension one and codimension two case. For instance, when dim=2 and spacedim=3, we can map the quadrature points so that they live on the physical triangle embedded in the three dimensional space. In such a case, the matrix is not square anymore.
Parameters
[in]
vertices
The vertices of the simplex you wish to integrate on
/usr/share/doc/packages/dealii/doxygen/deal.II/classQuadrature.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classQuadrature.html 2024-12-27 18:25:10.612886155 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classQuadrature.html 2024-12-27 18:25:10.620886210 +0000
@@ -242,9 +242,9 @@
At least for quadrilaterals and hexahedra (or, more precisely, since we work on reference cells: for the unit square and the unit cube), quadrature formulas are typically tensor products of one-dimensional formulas (see also the section on implementation detail below).
In order to allow for dimension independent programming, a quadrature formula of dimension zero exists. Since an integral over zero dimensions is the evaluation at a single point, any constructor of such a formula initializes to a single quadrature point with weight one. Access to the weight is possible, while access to the quadrature point is not permitted, since a Point of dimension zero contains no information. The main purpose of these formulae is their use in QProjector, which will create a useful formula of dimension one out of them.
Mathematical background
-
For each quadrature formula we denote by m, the maximal degree of polynomials integrated exactly on the reference cell the quadrature formula corresponds to. This number is given in the documentation of each formula. The order of the integration error is m+1, that is, the error is the size of the cell to the m+1 by the Bramble-Hilbert Lemma. The number m is to be found in the documentation of each concrete formula. For the optimal formulae QGauss we have , where is the constructor parameter to QGauss. The tensor product formulae are exact on tensor product polynomials of degree m in each space direction, but they are still only of (m+1)st order.
+
For each quadrature formula we denote by m, the maximal degree of polynomials integrated exactly on the reference cell the quadrature formula corresponds to. This number is given in the documentation of each formula. The order of the integration error is m+1, that is, the error is the size of the cell to the m+1 by the Bramble-Hilbert Lemma. The number m is to be found in the documentation of each concrete formula. For the optimal formulae QGauss we have , where is the constructor parameter to QGauss. The tensor product formulae are exact on tensor product polynomials of degree m in each space direction, but they are still only of (m+1)st order.
At least for hypercube reference cells (i.e., squares and cubes), most integration formulae in more than one space dimension are tensor products of quadrature formulae in one space dimension, or more generally the tensor product of a formula in (dim-1) dimensions and one in one dimension. There is a special constructor to generate a quadrature formula from two others. For example, the QGauss<dim> formulae include Ndim quadrature points in dim dimensions, where is the constructor parameter of QGauss.
+
At least for hypercube reference cells (i.e., squares and cubes), most integration formulae in more than one space dimension are tensor products of quadrature formulae in one space dimension, or more generally the tensor product of a formula in (dim-1) dimensions and one in one dimension. There is a special constructor to generate a quadrature formula from two others. For example, the QGauss<dim> formulae include Ndim quadrature points in dim dimensions, where is the constructor parameter of QGauss.
Other uses of this class
Quadrature objects are used in a number of places within deal.II where integration is performed, most notably via the FEValues and related classes. Some of these classes are also used in contexts where no integrals are involved, but where functions need to be evaluated at specific points, for example to evaluate the solution at individual points or to create graphical output. Examples are the implementation of VectorTools::point_value() and the DataOut and related classes (in particular in connection with the DataPostprocessor class). In such contexts, one often creates specific "Quadrature" objects in which the "quadrature points" are simply the points (in the coordinate system of the reference cell) at which one wants to evaluate the solution. In these kinds of cases, the weights stored by the current class are not used and the name "quadrature object" is interpreted as "list of evaluation points".
/usr/share/doc/packages/dealii/doxygen/deal.II/classReferenceCell.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classReferenceCell.html 2024-12-27 18:25:10.684886649 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classReferenceCell.html 2024-12-27 18:25:10.688886677 +0000
@@ -499,7 +499,7 @@
-
Compute the value of the -th linear shape function at location for the current reference-cell type.
+
Compute the value of the -th linear shape function at location for the current reference-cell type.
Return the -dimensional volume of the reference cell that corresponds to the current object, where is the dimension of the space it lives in. For example, since the quadrilateral reference cell is , its volume is one, whereas the volume of the reference triangle is 0.5 because it occupies the area .
+
Return the -dimensional volume of the reference cell that corresponds to the current object, where is the dimension of the space it lives in. For example, since the quadrilateral reference cell is , its volume is one, whereas the volume of the reference triangle is 0.5 because it occupies the area .
For ReferenceCells::Vertex, the reference cell is a zero-dimensional point in a zero-dimensional space. As a consequence, one cannot meaningfully define a volume for it. The function returns one for this case, because this makes it possible to define useful quadrature rules based on the center of a reference cell and its volume.
Return the barycenter (i.e., the center of mass) of the reference cell that corresponds to the current object. The function is not called center() because one can define the center of an object in a number of different ways whereas the barycenter of a reference cell is unambiguously defined as
-
+\]" src="form_1546.png"/>
where is the volume of the reference cell (see also the volume() function).
@@ -1494,7 +1494,7 @@
-
Return true if the given point is inside the reference cell of the present space dimension up to some tolerance. This function accepts an additional parameter (which defaults to zero) which specifies by how much the point position may actually be outside the true reference cell. This is useful because in practice we may often not be able to compute the coordinates of a point in reference coordinates exactly, but only up to numerical roundoff. For example, strictly speaking one would expect that for points on the boundary of the reference cell, the function would return true if the tolerance was zero. But in practice, this may or may not actually be true; for example, the point is on the boundary of the reference triangle because , but since neither of its coordinates are exactly representable in floating point arithmetic, the floating point representations of and may or may not add up to anything that is less than or equal to one.
+
Return true if the given point is inside the reference cell of the present space dimension up to some tolerance. This function accepts an additional parameter (which defaults to zero) which specifies by how much the point position may actually be outside the true reference cell. This is useful because in practice we may often not be able to compute the coordinates of a point in reference coordinates exactly, but only up to numerical roundoff. For example, strictly speaking one would expect that for points on the boundary of the reference cell, the function would return true if the tolerance was zero. But in practice, this may or may not actually be true; for example, the point is on the boundary of the reference triangle because , but since neither of its coordinates are exactly representable in floating point arithmetic, the floating point representations of and may or may not add up to anything that is less than or equal to one.
The tolerance parameter may be less than zero, indicating that the point should be safely inside the cell.
Return -th unit tangential vector of a face of the reference cell. The vectors are arranged such that the cross product between the two vectors returns the unit normal vector.
-
Precondition
must be between zero and dim-1.
+
Return -th unit tangential vector of a face of the reference cell. The vectors are arranged such that the cross product between the two vectors returns the unit normal vector.
Given a set of node indices of the form or or (depending on whether the reference cell is in 1d, 2d, or 3d), return the index the VTK format uses for this node for cells that are subdivided as many times in each of the coordinate directions as described by the second argument. For a uniformly subdivided cell, the second argument is an array whose elements will all be equal.
+
Given a set of node indices of the form or or (depending on whether the reference cell is in 1d, 2d, or 3d), return the index the VTK format uses for this node for cells that are subdivided as many times in each of the coordinate directions as described by the second argument. For a uniformly subdivided cell, the second argument is an array whose elements will all be equal.
The last argument, legacy_format, indicates whether to use the old, VTK legacy format (when true) or the new, VTU format (when false).
/usr/share/doc/packages/dealii/doxygen/deal.II/classRol_1_1VectorAdaptor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classRol_1_1VectorAdaptor.html 2024-12-27 18:25:10.716886869 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classRol_1_1VectorAdaptor.html 2024-12-27 18:25:10.716886869 +0000
@@ -544,7 +544,7 @@
-
Create and return a Teuchos smart reference counting pointer to the basis vector corresponding to the i element of the wrapper vector.
+
Create and return a Teuchos smart reference counting pointer to the basis vector corresponding to the i element of the wrapper vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverArnoldi.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverArnoldi.html 2024-12-27 18:25:10.752887116 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverArnoldi.html 2024-12-27 18:25:10.756887143 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverGeneralizedDavidson.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverGeneralizedDavidson.html 2024-12-27 18:25:10.832887665 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverGeneralizedDavidson.html 2024-12-27 18:25:10.836887693 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverJacobiDavidson.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverJacobiDavidson.html 2024-12-27 18:25:10.876887967 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverJacobiDavidson.html 2024-12-27 18:25:10.880887995 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverKrylovSchur.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverKrylovSchur.html 2024-12-27 18:25:10.916888242 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverKrylovSchur.html 2024-12-27 18:25:10.920888270 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLAPACK.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLAPACK.html 2024-12-27 18:25:10.960888544 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLAPACK.html 2024-12-27 18:25:10.964888572 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLanczos.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLanczos.html 2024-12-27 18:25:11.000888819 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverLanczos.html 2024-12-27 18:25:11.004888846 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverPower.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverPower.html 2024-12-27 18:25:11.048889148 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSLEPcWrappers_1_1SolverPower.html 2024-12-27 18:25:11.052889176 +0000
@@ -265,7 +265,7 @@
-
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
+
Composite method that solves the eigensystem . The eigenvector sent in has to have at least one element that we can use as a template when resizing, since we do not know the parameters of the specific vector class used (i.e. local_dofs for MPI vectors). However, while copying eigenvectors, at least twice the memory size of eigenvectors is being used (and can be more). To avoid doing this, the fairly standard calling sequence executed here is used: Set up matrices for solving; Actually solve the system; Gather the solution(s).
Note
Note that the number of converged eigenvectors can be larger than the number of eigenvectors requested; this is due to a round off error (success) of the eigenproblem solver context. If this is found to be the case we simply do not bother with more eigenpairs than requested, but handle that it may be more than specified by ignoring any extras. By default one eigenvector/eigenvalue pair is computed.
This is declared here to make it possible to take a std::vector of different PETScWrappers vector types
@@ -312,9 +312,9 @@
-
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
+
Same as above, but here a composite method for solving the system , for real matrices, vectors, and values .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1ARKode.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1ARKode.html 2024-12-27 18:25:11.100889506 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1ARKode.html 2024-12-27 18:25:11.100889506 +0000
@@ -211,85 +211,85 @@
The class ARKode is a wrapper to SUNDIALS variable-step, embedded, additive Runge-Kutta solver which is a general purpose solver for systems of ordinary differential equations characterized by the presence of both fast and slow dynamics.
Fast dynamics are treated implicitly, and slow dynamics are treated explicitly, using nested families of implicit and explicit Runge-Kutta solvers.
ARKode solves ODE initial value problems (IVPs) in . These problems should be posed in explicit form as
+
ARKode solves ODE initial value problems (IVPs) in . These problems should be posed in explicit form as
-
+ \]" src="form_2645.png"/>
-
Here, is the independent variable (e.g. time), and the dependent variables are given by , and we use notation to denote . is a user-supplied nonsingular operator from . This operator may depend on but not on .
-
For standard systems of ordinary differential equations and for problems arising from the spatial semi-discretization of partial differential equations using finite difference or finite volume methods, is typically the identity matrix, . For PDEs using a finite-element spatial semi-discretization is typically a well-conditioned mass matrix.
+
Here, is the independent variable (e.g. time), and the dependent variables are given by , and we use notation to denote . is a user-supplied nonsingular operator from . This operator may depend on but not on .
+
For standard systems of ordinary differential equations and for problems arising from the spatial semi-discretization of partial differential equations using finite difference or finite volume methods, is typically the identity matrix, . For PDEs using a finite-element spatial semi-discretization is typically a well-conditioned mass matrix.
The two right-hand side functions may be described as:
-
: contains the "slow" time scale components of the system. This will be integrated using explicit methods.
-
: contains the "fast" time scale components of the system. This will be integrated using implicit methods.
+
: contains the "slow" time scale components of the system. This will be integrated using explicit methods.
+
: contains the "fast" time scale components of the system. This will be integrated using implicit methods.
-
ARKode may be used to solve stiff, nonstiff and multi-rate problems. Roughly speaking, stiffness is characterized by the presence of at least one rapidly damped mode, whose time constant is small compared to the time scale of the solution itself. In the implicit/explicit (ImEx) splitting above, these stiff components should be included in the right-hand side function .
-
For multi-rate problems, a user should provide both of the functions and that define the IVP system.
-
For nonstiff problems, only should be provided, and is assumed to be zero, i.e. the system reduces to the non-split IVP:
+
ARKode may be used to solve stiff, nonstiff and multi-rate problems. Roughly speaking, stiffness is characterized by the presence of at least one rapidly damped mode, whose time constant is small compared to the time scale of the solution itself. In the implicit/explicit (ImEx) splitting above, these stiff components should be included in the right-hand side function .
+
For multi-rate problems, a user should provide both of the functions and that define the IVP system.
+
For nonstiff problems, only should be provided, and is assumed to be zero, i.e. the system reduces to the non-split IVP:
-
+ \]" src="form_2655.png"/>
-
In this scenario, the ARK methods reduce to classical explicit Runge-Kutta methods (ERK). For these classes of methods, ARKode allows orders of accuracy , with embeddings of orders . These default to the Heun-Euler-2-1-2, Bogacki-Shampine-4-2-3, Zonneveld-5-3-4, Cash-Karp-6-4-5, Verner-8-5-6 and Fehlberg-13-7-8 methods, respectively.
-
Finally, for stiff (linear or nonlinear) problems the user may provide only , implying that , so that the system reduces to the non-split IVP
+
In this scenario, the ARK methods reduce to classical explicit Runge-Kutta methods (ERK). For these classes of methods, ARKode allows orders of accuracy , with embeddings of orders . These default to the Heun-Euler-2-1-2, Bogacki-Shampine-4-2-3, Zonneveld-5-3-4, Cash-Karp-6-4-5, Verner-8-5-6 and Fehlberg-13-7-8 methods, respectively.
+
Finally, for stiff (linear or nonlinear) problems the user may provide only , implying that , so that the system reduces to the non-split IVP
-
+ \]" src="form_2659.png"/>
-
Similarly to ERK methods, in this scenario the ARK methods reduce to classical diagonally-implicit Runge-Kutta methods (DIRK). For these classes of methods, ARKode allows orders of accuracy , with embeddings of orders . These default to the SDIRK-2-1-2, ARK-4-2-3 (implicit), SDIRK-5-3-4 and ARK-8-4-5 (implicit) methods, respectively.
+
Similarly to ERK methods, in this scenario the ARK methods reduce to classical diagonally-implicit Runge-Kutta methods (DIRK). For these classes of methods, ARKode allows orders of accuracy , with embeddings of orders . These default to the SDIRK-2-1-2, ARK-4-2-3 (implicit), SDIRK-5-3-4 and ARK-8-4-5 (implicit) methods, respectively.
For both DIRK and ARK methods, an implicit system of the form
-
+ \]" src="form_2662.png"/>
-
must be solved for each stage , where we have the data
-, where we have the data
+
+ \]" src="form_2664.png"/>
for the ARK methods, or
-
+ \]" src="form_2665.png"/>
-
for the DIRK methods. Here and are the Butcher's tables for the chosen solver.
-
If depends nonlinearly on then the systems above correspond to a nonlinear system of equations; if depends linearly on then this is a linear system of equations. By specifying the flag implicit_function_is_linear, ARKode takes some shortcuts that allow a faster solution process.
+
for the DIRK methods. Here and are the Butcher's tables for the chosen solver.
+
If depends nonlinearly on then the systems above correspond to a nonlinear system of equations; if depends linearly on then this is a linear system of equations. By specifying the flag implicit_function_is_linear, ARKode takes some shortcuts that allow a faster solution process.
For systems of either type, ARKode allows a choice of solution strategy. The default solver choice is a variant of Newton's method,
-
+ \]" src="form_2669.png"/>
-
where is the Newton step index, and the Newton update requires the solution of the linear Newton system
- is the Newton step index, and the Newton update requires the solution of the linear Newton system
+
+ \]" src="form_2671.png"/>
where
-
+ \]" src="form_2672.png"/>
-
As an alternate to Newton's method, ARKode may solve for each stage using an Anderson-accelerated fixed point iteration
-ARKode may solve for each stage using an Anderson-accelerated fixed point iteration
+
+ \]" src="form_2674.png"/>
Unlike with Newton's method, this option does not require the solution of a linear system at each iteration, instead opting for solution of a low-dimensional least-squares solution to construct the nonlinear update.
-
Finally, if the user specifies implicit_function_is_linear, i.e., depends linearly on , and if the Newton-based nonlinear solver is chosen, then the system will be solved using only a single Newton iteration. Notice that in order for the Newton solver to be used, then jacobian_times_vector() should be supplied. If it is not supplied then only the fixed-point iteration will be supported, and the implicit_function_is_linear setting is ignored.
-
The optimal solver (Newton vs fixed-point) is highly problem-dependent. Since fixed-point solvers do not require the solution of any linear systems, each iteration may be significantly less costly than their Newton counterparts. However, this can come at the cost of slower convergence (or even divergence) in comparison with Newton-like methods. These fixed-point solvers do allow for user specification of the Anderson-accelerated subspace size, . While the required amount of solver memory grows proportionately to , larger values of may result in faster convergence.
-
This improvement may be significant even for "small" values, e.g. , and convergence may not improve (or even deteriorate) for larger values of . While ARKode uses a Newton-based iteration as its default solver due to its increased robustness on very stiff problems, it is highly recommended that users also consider the fixed-point solver for their cases when attempting a new problem.
-
For either the Newton or fixed-point solvers, it is well-known that both the efficiency and robustness of the algorithm intimately depends on the choice of a good initial guess. In ARKode, the initial guess for either nonlinear solution method is a predicted value that is computed explicitly from the previously-computed data (e.g. , and where ). Additional information on the specific predictor algorithms implemented in ARKode is provided in ARKode documentation.
+
Finally, if the user specifies implicit_function_is_linear, i.e., depends linearly on , and if the Newton-based nonlinear solver is chosen, then the system will be solved using only a single Newton iteration. Notice that in order for the Newton solver to be used, then jacobian_times_vector() should be supplied. If it is not supplied then only the fixed-point iteration will be supported, and the implicit_function_is_linear setting is ignored.
+
The optimal solver (Newton vs fixed-point) is highly problem-dependent. Since fixed-point solvers do not require the solution of any linear systems, each iteration may be significantly less costly than their Newton counterparts. However, this can come at the cost of slower convergence (or even divergence) in comparison with Newton-like methods. These fixed-point solvers do allow for user specification of the Anderson-accelerated subspace size, . While the required amount of solver memory grows proportionately to , larger values of may result in faster convergence.
+
This improvement may be significant even for "small" values, e.g. , and convergence may not improve (or even deteriorate) for larger values of . While ARKode uses a Newton-based iteration as its default solver due to its increased robustness on very stiff problems, it is highly recommended that users also consider the fixed-point solver for their cases when attempting a new problem.
+
For either the Newton or fixed-point solvers, it is well-known that both the efficiency and robustness of the algorithm intimately depends on the choice of a good initial guess. In ARKode, the initial guess for either nonlinear solution method is a predicted value that is computed explicitly from the previously-computed data (e.g. , and where ). Additional information on the specific predictor algorithms implemented in ARKode is provided in ARKode documentation.
The user has to provide the implementation of at least one (or both) of the following std::functions:
A function object that users may supply and that is intended to compute the explicit part of the IVP right hand side. Sets .
+
A function object that users may supply and that is intended to compute the explicit part of the IVP right hand side. Sets .
At least one of explicit_function() or implicit_function() must be provided. According to which one is provided, explicit, implicit, or mixed RK methods are used.
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. In particular, ARKode can deal with "recoverable" errors in some circumstances, so callbacks can throw exceptions of type RecoverableUserCallbackError.
@@ -755,8 +755,8 @@
-
A function object that users may supply and that is intended to compute the implicit part of the IVP right hand side. Sets .
+
A function object that users may supply and that is intended to compute the implicit part of the IVP right hand side. Sets .
At least one of explicit_function() or implicit_function() must be provided. According to which one is provided, explicit, implicit, or mixed RK methods are used.
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. In particular, ARKode can deal with "recoverable" errors in some circumstances, so callbacks can throw exceptions of type RecoverableUserCallbackError.
@@ -778,7 +778,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA.html 2024-12-27 18:25:11.148889835 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA.html 2024-12-27 18:25:11.152889863 +0000
@@ -203,72 +203,72 @@
Consider a system of Differential-Algebraic Equations written in the general form
-
+ \]" src="form_2701.png"/>
-
where are vectors in , is often the time (but can also be a parametric quantity), and . Such problem is solved using Newton iteration augmented with a line search global strategy. The integration method used in IDA is the variable-order, variable-coefficient BDF (Backward Differentiation Formula), in fixed-leading-coefficient. The method order ranges from 1 to 5, with the BDF of order given by the multistep formula
+
where are vectors in , is often the time (but can also be a parametric quantity), and . Such problem is solved using Newton iteration augmented with a line search global strategy. The integration method used in IDA is the variable-order, variable-coefficient BDF (Backward Differentiation Formula), in fixed-leading-coefficient. The method order ranges from 1 to 5, with the BDF of order given by the multistep formula
-
+ \]" src="form_2705.png"/>
-
where and are the computed approximations of and , respectively, and the step size is . The coefficients are uniquely determined by the order , and the history of the step sizes. The application of the BDF method to the DAE system results in a nonlinear algebraic system to be solved at each time step:
+
where and are the computed approximations of and , respectively, and the step size is . The coefficients are uniquely determined by the order , and the history of the step sizes. The application of the BDF method to the DAE system results in a nonlinear algebraic system to be solved at each time step:
-
+ \]" src="form_2712.png"/>
The Newton method leads to a linear system of the form
-
+ \]" src="form_2713.png"/>
-
where is the -th approximation to , and is the approximation of the system Jacobian
+
where is the -th approximation to , and is the approximation of the system Jacobian
-
+ \]" src="form_2715.png"/>
-
and . It is worth mentioning that the scalar changes whenever the step size or method order changes.
+
and . It is worth mentioning that the scalar changes whenever the step size or method order changes.
A simple example: an ordinary differential equation
To provide a simple example, consider the following harmonic oscillator problem:
-
+ \]" src="form_2717.png"/>
We write it in terms of a first order ode:
-
+ \]" src="form_2718.png"/>
-
That is, where
- where
+
+ \]" src="form_2720.png"/>
-
and , .
-
The exact solution is , , .
-
The Jacobian to assemble is the following: .
+
and , .
+
The exact solution is , , .
+
The Jacobian to assemble is the following: .
This is achieved by the following snippet of code:
A more interesting example is a situation where the form provides something genuinely more flexible than a typical ordinary differential equation. Specifically, consider the equation
- provides something genuinely more flexible than a typical ordinary differential equation. Specifically, consider the equation
+
+ \end{align*}" src="form_2726.png"/>
-
One can combine the two variables into . Here, one of the two variables does not have a time derivative. In applications, this is often the case when one variable evolves in time (here, ) on its own time scale, and the other one finds its value as a function of the former on a much faster time scale. In the current context, we could of course easily eliminate using the second equation, and would then just be left with the equation
-. Here, one of the two variables does not have a time derivative. In applications, this is often the case when one variable evolves in time (here, ) on its own time scale, and the other one finds its value as a function of the former on a much faster time scale. In the current context, we could of course easily eliminate using the second equation, and would then just be left with the equation
+
+ \]" src="form_2730.png"/>
-
which has solution . But this is, in general, not easily possible if the two variables are related by differential operators. In fact, this happens quite frequently in application. Take, for example, the time-dependent Stokes equations:
-. But this is, in general, not easily possible if the two variables are related by differential operators. In fact, this happens quite frequently in application. Take, for example, the time-dependent Stokes equations:
+
+ \end{align*}" src="form_2732.png"/>
-
Here, the fluid velocity evolves over time, and the pressure is always in equilibrium with the flow because the Stokes equations are derived under the assumption that the speed of sound (at which pressure perturbations propagate) is much larger than the fluid velocity. As a consequence, there is no time derivative on the pressure available in the equation, but unlike the simple model problem above, the pressure can not easily be eliminated from the system. Similar situations happen in step-21, step-31, step-32, step-43, and others, where a subset of variables is always in instantaneous equilibrium with another set of variables that evolves on a slower time scale.
+
Here, the fluid velocity evolves over time, and the pressure is always in equilibrium with the flow because the Stokes equations are derived under the assumption that the speed of sound (at which pressure perturbations propagate) is much larger than the fluid velocity. As a consequence, there is no time derivative on the pressure available in the equation, but unlike the simple model problem above, the pressure can not easily be eliminated from the system. Similar situations happen in step-21, step-31, step-32, step-43, and others, where a subset of variables is always in instantaneous equilibrium with another set of variables that evolves on a slower time scale.
Another case where we could eliminate a variable but do not want to is where that additional variable is introduced in the first place to work around some other problem. As an example, consider the time dependent version of the biharmonic problem we consider in step-47 (as well as some later ones). The equations we would then be interested in would read
-
+ \end{align*}" src="form_2734.png"/>
-
As discussed in step-47, the difficulty is the presence of the fourth derivatives. One way in which one can address this is by introducing an auxiliary variable which would render the problem into the following one that only ever has second derivatives which we know how to deal with:
-step-47, the difficulty is the presence of the fourth derivatives. One way in which one can address this is by introducing an auxiliary variable which would render the problem into the following one that only ever has second derivatives which we know how to deal with:
+
+ \end{align*}" src="form_2736.png"/>
-
Here, the introduction of the additional variable was voluntary, and could be undone, but we don't want that of course. Rather, we end up with a differential-algebraic equation because the equations do not have a time derivative for .
-
Rather than show how to solve the trivial (linear) case above, let us instead consider the situation where we introduce another variable that is related to by the nonlinear relationship , :
-.
+
Rather than show how to solve the trivial (linear) case above, let us instead consider the situation where we introduce another variable that is related to by the nonlinear relationship , :
+
+ \end{align*}" src="form_2739.png"/>
We will impose initial conditions as
-
+ \end{align*}" src="form_2740.png"/>
-
The problem continues to have the solution with the auxiliary variable satisfying . One would implement all of this using the following little program where you have to recall that
- with the auxiliary variable satisfying . One would implement all of this using the following little program where you have to recall that
+
+ \]" src="form_2743.png"/>
and that the Jacobian we need to provide is
-
+ \]" src="form_2744.png"/>
All of this can be implemented using the following code:
Note that in this code, we not only provide initial conditions for and , but also for and . We can do this here because we know what the exact solution is.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA_1_1AdditionalData.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA_1_1AdditionalData.html 2024-12-27 18:25:11.184890082 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSUNDIALS_1_1IDA_1_1AdditionalData.html 2024-12-27 18:25:11.188890110 +0000
@@ -179,14 +179,14 @@
-
IDA is a Differential Algebraic solver. As such, it requires initial conditions also for the first order derivatives. If you do not provide consistent initial conditions, (i.e., conditions for which , you can ask SUNDIALS to compute initial conditions for you by specifying InitialConditionCorrection for the initial conditions both at the initial_time (ic_type) and after a reset has occurred (reset_type).
+
IDA is a Differential Algebraic solver. As such, it requires initial conditions also for the first order derivatives. If you do not provide consistent initial conditions, (i.e., conditions for which , you can ask SUNDIALS to compute initial conditions for you by specifying InitialConditionCorrection for the initial conditions both at the initial_time (ic_type) and after a reset has occurred (reset_type).
Enumerator
none&#href_anchor"fielddoc">
Do not try to make initial conditions consistent.
-
use_y_diff
Compute the algebraic components of and differential components of , given the differential components of . This option requires that the user specifies differential and algebraic components in the function IDA::differential_components().
+
use_y_diff
Compute the algebraic components of and differential components of , given the differential components of . This option requires that the user specifies differential and algebraic components in the function IDA::differential_components().
-
use_y_dot
Compute all components of , given .
+
use_y_dot
Compute all components of , given .
@@ -565,8 +565,8 @@
Type of correction for initial conditions.
-
If you do not provide consistent initial conditions, (i.e., conditions for which ), you can ask SUNDIALS to compute initial conditions for you by using the ic_type parameter at construction time.
-
Notice that you could in principle use this capabilities to solve for steady state problems by setting y_dot to zero, and asking to compute that satisfies , however the nonlinear solver used inside IDA may not be robust enough for complex problems with several millions unknowns.
+
If you do not provide consistent initial conditions, (i.e., conditions for which ), you can ask SUNDIALS to compute initial conditions for you by using the ic_type parameter at construction time.
+
Notice that you could in principle use this capabilities to solve for steady state problems by setting y_dot to zero, and asking to compute that satisfies , however the nonlinear solver used inside IDA may not be robust enough for complex problems with several millions unknowns.
KINSOL is a solver for nonlinear algebraic systems in residual form or fixed point form , where is a vector which we will assume to be in or , but that may also have a block structure and may be distributed in parallel computations; the functions and satisfy or . It includes a Newton-Krylov solver as well as Picard and fixed point solvers, both of which can be accelerated with Anderson acceleration. KINSOL is based on the previous Fortran package NKSOL of Brown and Saad. An example of using KINSOL can be found in the step-77 tutorial program.
+
KINSOL is a solver for nonlinear algebraic systems in residual form or fixed point form , where is a vector which we will assume to be in or , but that may also have a block structure and may be distributed in parallel computations; the functions and satisfy or . It includes a Newton-Krylov solver as well as Picard and fixed point solvers, both of which can be accelerated with Anderson acceleration. KINSOL is based on the previous Fortran package NKSOL of Brown and Saad. An example of using KINSOL can be found in the step-77 tutorial program.
KINSOL's Newton solver employs the inexact Newton method. As this solver is intended mainly for large systems, the user is required to provide their own solver function.
At the highest level, KINSOL implements the following iteration scheme:
-
set = an initial guess
-
For until convergence do:
-
Solve
-
Set
+
set = an initial guess
+
For until convergence do:
+
Solve
+
Set
Test for convergence
-
Here, is the -th iterate to , and is the system Jacobian. At each stage in the iteration process, a scalar multiple of the step , is added to to produce a new iterate, . A test for convergence is made before the iteration continues.
+
Here, is the -th iterate to , and is the system Jacobian. At each stage in the iteration process, a scalar multiple of the step , is added to to produce a new iterate, . A test for convergence is made before the iteration continues.
Unless specified otherwise by the user, KINSOL strives to update Jacobian information as infrequently as possible to balance the high costs of matrix operations against other costs. Specifically, these updates occur when:
the problem is initialized,
-
(inexact Newton only, see below for a definition of )
+
(inexact Newton only, see below for a definition of )
a specified number of nonlinear iterations have passed since the last update,
the linear solver failed recoverably with outdated Jacobian information,
the global strategy failed with outdated Jacobian information, or
-
tolerance with outdated Jacobian information.
+
tolerance with outdated Jacobian information.
KINSOL allows changes to the above strategy through optional solver inputs. The user can disable the initial Jacobian information evaluation or change the default value of the number of nonlinear iterations after which a Jacobian information update is enforced.
-
To address the case of ill-conditioned nonlinear systems, KINSOL allows prescribing scaling factors both for the solution vector and for the residual vector. For scaling to be used, the user may supply the function get_solution_scaling(), that returns values , which are diagonal elements of the scaling matrix such that has all components roughly the same magnitude when is close to a solution, and get_function_scaling(), that supply values , which are diagonal scaling matrix elements such that has all components roughly the same magnitude when is not too close to a solution.
+
To address the case of ill-conditioned nonlinear systems, KINSOL allows prescribing scaling factors both for the solution vector and for the residual vector. For scaling to be used, the user may supply the function get_solution_scaling(), that returns values , which are diagonal elements of the scaling matrix such that has all components roughly the same magnitude when is close to a solution, and get_function_scaling(), that supply values , which are diagonal scaling matrix elements such that has all components roughly the same magnitude when is not too close to a solution.
When scaling values are provided for the solution vector, these values are automatically incorporated into the calculation of the perturbations used for the default difference quotient approximations for Jacobian information if the user does not supply a Jacobian solver through the solve_with_jacobian() function.
-
Two methods of applying a computed step to the previously computed solution vector are implemented. The first and simplest is the standard Newton strategy which applies the update with a constant always set to 1. The other method is a global strategy, which attempts to use the direction implied by in the most efficient way for furthering convergence of the nonlinear problem. This technique is implemented in the second strategy, called Linesearch. This option employs both the and conditions of the Goldstein-Armijo linesearch algorithm given in [DennisSchnabel96] , where is chosen to guarantee a sufficient decrease in relative to the step length as well as a minimum step length relative to the initial rate of decrease of . One property of the algorithm is that the full Newton step tends to be taken close to the solution.
+
Two methods of applying a computed step to the previously computed solution vector are implemented. The first and simplest is the standard Newton strategy which applies the update with a constant always set to 1. The other method is a global strategy, which attempts to use the direction implied by in the most efficient way for furthering convergence of the nonlinear problem. This technique is implemented in the second strategy, called Linesearch. This option employs both the and conditions of the Goldstein-Armijo linesearch algorithm given in [DennisSchnabel96] , where is chosen to guarantee a sufficient decrease in relative to the step length as well as a minimum step length relative to the initial rate of decrease of . One property of the algorithm is that the full Newton step tends to be taken close to the solution.
The basic fixed-point iteration scheme implemented in KINSOL is given by:
-
Set an initial guess
-
For until convergence do:
-
Set
+
Set an initial guess
+
For until convergence do:
+
Set
Test for convergence
-
At each stage in the iteration process, function is applied to the current iterate to produce a new iterate, . A test for convergence is made before the iteration continues.
-
For Picard iteration, as implemented in KINSOL, we consider a special form of the nonlinear function , such that , where is a constant nonsingular matrix and is (in general) nonlinear.
-
Then the fixed-point function is defined as . Within each iteration, the Picard step is computed then added to to produce the new iterate. Next, the nonlinear residual function is evaluated at the new iterate, and convergence is checked. The Picard and fixed point methods can be significantly accelerated using Anderson's acceleration method.
+
At each stage in the iteration process, function is applied to the current iterate to produce a new iterate, . A test for convergence is made before the iteration continues.
+
For Picard iteration, as implemented in KINSOL, we consider a special form of the nonlinear function , such that , where is a constant nonsingular matrix and is (in general) nonlinear.
+
Then the fixed-point function is defined as . Within each iteration, the Picard step is computed then added to to produce the new iterate. Next, the nonlinear residual function is evaluated at the new iterate, and convergence is checked. The Picard and fixed point methods can be significantly accelerated using Anderson's acceleration method.
The user has to provide the implementation of the following std::functions:
reinit_vector; and only one of
residual; or
iteration_function;
-
Specifying residual() allows the user to use Newton and Picard strategies (i.e., will be solved), while specifying iteration_function(), a fixed point iteration will be used (i.e., will be solved). An error will be thrown if iteration_function() is set for Picard or Newton.
+
Specifying residual() allows the user to use Newton and Picard strategies (i.e., will be solved), while specifying iteration_function(), a fixed point iteration will be used (i.e., will be solved). An error will be thrown if iteration_function() is set for Picard or Newton.
If the use of a Newton or Picard method is desired, then the user should also supply
solve_with_jacobian; and optionally
setup_jacobian;
@@ -430,7 +430,7 @@
-
A function object that users should supply and that is intended to compute the iteration function for the fixed point iteration. This function is only used if the SolutionStrategy::fixed_point strategy is selected.
+
A function object that users should supply and that is intended to compute the iteration function for the fixed point iteration. This function is only used if the SolutionStrategy::fixed_point strategy is selected.
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. In particular, KINSOL can deal with "recoverable" errors in some circumstances, so callbacks can throw exceptions of type RecoverableUserCallbackError.
A function object that users may supply and that is intended to prepare the linear solver for subsequent calls to solve_with_jacobian().
The job of setup_jacobian() is to prepare the linear solver for subsequent calls to solve_with_jacobian(), in the solution of linear systems . The exact nature of this system depends on the SolutionStrategy that has been selected.
-
In the cases strategy = SolutionStrategy::newton or SolutionStrategy::linesearch, is the Jacobian . If strategy = SolutionStrategy::picard, is the approximate Jacobian matrix . If strategy = SolutionStrategy::fixed_point, then linear systems do not arise, and this function is never called.
+
In the cases strategy = SolutionStrategy::newton or SolutionStrategy::linesearch, is the Jacobian . If strategy = SolutionStrategy::picard, is the approximate Jacobian matrix . If strategy = SolutionStrategy::fixed_point, then linear systems do not arise, and this function is never called.
The setup_jacobian() function may call a user-supplied function, or a function within the linear solver group, to compute Jacobian-related data that is required by the linear solver. It may also preprocess that data as needed for solve_with_jacobian(), which may involve calling a generic function (such as for LU factorization) or, more generally, build preconditioners from the assembled Jacobian. In any case, the data so generated may then be used whenever a linear system is solved.
The point of this function is that setup_jacobian() function is not called at every Newton iteration, but only as frequently as the solver determines that it is appropriate to perform the setup task. In this way, Jacobian-related data generated by setup_jacobian() is expected to be used over a number of Newton iterations. KINSOL determines itself when it is beneficial to regenerate the Jacobian and associated information (such as preconditioners computed for the Jacobian), thereby saving the effort to regenerate the Jacobian matrix and a preconditioner for it whenever possible.
Parameters
-
current_u
Current value of
-
current_f
Current value of or
+
current_u
Current value of
+
current_f
Current value of or
@@ -484,12 +484,12 @@
A function object that users may supply and that is intended to solve a linear system with the Jacobian matrix. This function will be called by KINSOL (possibly several times) after setup_jacobian() has been called at least once. KINSOL tries to do its best to call setup_jacobian() the minimum number of times. If convergence can be achieved without updating the Jacobian, then KINSOL does not call setup_jacobian() again. If, on the contrary, internal KINSOL convergence tests fail, then KINSOL calls setup_jacobian() again with updated vectors and coefficients so that successive calls to solve_with_jacobian() lead to better convergence in the Newton process.
If you do not specify a solve_with_jacobian function, then only a fixed point iteration strategy can be used. Notice that this may not converge, or may converge very slowly.
-
A call to this function should store in dst the result of applied to rhs, i.e., . It is the user's responsibility to set up proper solvers and preconditioners inside this function (or in the setup_jacobian callback above). The function attached to this callback is also provided with a tolerance to the linear solver, indicating that it is not necessary to solve the linear system with the Jacobian matrix exactly, but only to a tolerance that KINSOL will adapt over time.
+
A call to this function should store in dst the result of applied to rhs, i.e., . It is the user's responsibility to set up proper solvers and preconditioners inside this function (or in the setup_jacobian callback above). The function attached to this callback is also provided with a tolerance to the linear solver, indicating that it is not necessary to solve the linear system with the Jacobian matrix exactly, but only to a tolerance that KINSOL will adapt over time.
Arguments to the function are:
Parameters
[in]
rhs
The system right hand side to solve for.
-
[out]
dst
The solution of .
+
[out]
dst
The solution of .
[in]
tolerance
The tolerance with which to solve the linear system of equations.
@@ -514,7 +514,7 @@
A function object that users may supply and that is intended to return a vector whose components are the weights used by KINSOL to compute the vector norm of the solution. The implementation of this function is optional, and it is used only if implemented.
-
The intent for this scaling factor is for problems in which the different components of a solution have vastly different numerical magnitudes – typically because they have different physical units and represent different things. For example, if one were to solve a nonlinear Stokes problem, the solution vector has components that correspond to velocities and other components that correspond to pressures. These have different physical units and depending on which units one chooses, they may have roughly comparable numerical sizes or maybe they don't. To give just one example, in simulations of flow in the Earth's interior, one has velocities on the order of maybe ten centimeters per year, and pressures up to around 100 GPa. If one expresses this in SI units, this corresponds to velocities of around m/s, and pressures around , i.e., vastly different. In such cases, computing the norm of a solution-type vector (e.g., the difference between the previous and the current solution) makes no sense because the norm will either be dominated by the velocity components or the pressure components. The scaling vector this function returns is intended to provide each component of the solution with a scaling factor that is generally chosen as the inverse of a "typical velocity" or "typical pressure" so that upon multiplication of a vector component by the corresponding scaling vector component, one obtains a number that is of order of magnitude of one (i.e., a reasonably small multiple of one times the typical velocity/pressure). The KINSOL manual states this as follows: "The user should supply values \_form#href_anchor".
+
The intent for this scaling factor is for problems in which the different components of a solution have vastly different numerical magnitudes – typically because they have different physical units and represent different things. For example, if one were to solve a nonlinear Stokes problem, the solution vector has components that correspond to velocities and other components that correspond to pressures. These have different physical units and depending on which units one chooses, they may have roughly comparable numerical sizes or maybe they don't. To give just one example, in simulations of flow in the Earth's interior, one has velocities on the order of maybe ten centimeters per year, and pressures up to around 100 GPa. If one expresses this in SI units, this corresponds to velocities of around m/s, and pressures around , i.e., vastly different. In such cases, computing the norm of a solution-type vector (e.g., the difference between the previous and the current solution) makes no sense because the norm will either be dominated by the velocity components or the pressure components. The scaling vector this function returns is intended to provide each component of the solution with a scaling factor that is generally chosen as the inverse of a "typical velocity" or "typical pressure" so that upon multiplication of a vector component by the corresponding scaling vector component, one obtains a number that is of order of magnitude of one (i.e., a reasonably small multiple of one times the typical velocity/pressure). The KINSOL manual states this as follows: "The user should supply values \_form#href_anchor".
If no function is provided to a KINSOL object, then this is interpreted as implicitly saying that all of these scaling factors should be considered as one.
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. In particular, KINSOL can deal with "recoverable" errors in some circumstances, so callbacks can throw exceptions of type RecoverableUserCallbackError.
@@ -536,7 +536,7 @@
A function object that users may supply and that is intended to return a vector whose components are the weights used by KINSOL to compute the vector norm of the function evaluation away from the solution. The implementation of this function is optional, and it is used only if implemented.
-
The point of this function and the scaling vector it returns is similar to the one discussed above for get_solution_scaling, except that it is for a vector that scales the components of the function , rather than the components of , when computing norms. As above, if no function is provided, then this is equivalent to using a scaling vector whose components are all equal to one.
+
The point of this function and the scaling vector it returns is similar to the one discussed above for get_solution_scaling, except that it is for a vector that scales the components of the function , rather than the components of , when computing norms. As above, if no function is provided, then this is equivalent to using a scaling vector whose components are all equal to one.
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. In particular, KINSOL can deal with "recoverable" errors in some circumstances, so callbacks can throw exceptions of type RecoverableUserCallbackError.
The relative error in computing , which is used in the difference quotient approximation to the Jacobian matrix when the user does not supply a solve_with_jacobian() function.
+
The relative error in computing , which is used in the difference quotient approximation to the Jacobian matrix when the user does not supply a solve_with_jacobian() function.
If set to zero, default values provided by KINSOL will be used.
/usr/share/doc/packages/dealii/doxygen/deal.II/classScaLAPACKMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classScaLAPACKMatrix.html 2024-12-27 18:25:11.352891236 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classScaLAPACKMatrix.html 2024-12-27 18:25:11.352891236 +0000
@@ -373,15 +373,15 @@
Detailed Description
template<typename NumberType>
class ScaLAPACKMatrix< NumberType >
A wrapper class around ScaLAPACK parallel dense linear algebra.
-
ScaLAPACK assumes that matrices are distributed according to the block-cyclic decomposition scheme. An by matrix is first decomposed into by blocks which are then uniformly distributed across the 2d process grid with processes, where are grid dimensions and is the total number of processes. The parameters MB and NB are referred to as row and column block size and determine the granularity of the block-cyclic distribution.
-
In the following the block-cyclic distribution of a matrix onto a Cartesian process grid with block sizes is displayed.
+
ScaLAPACK assumes that matrices are distributed according to the block-cyclic decomposition scheme. An by matrix is first decomposed into by blocks which are then uniformly distributed across the 2d process grid with processes, where are grid dimensions and is the total number of processes. The parameters MB and NB are referred to as row and column block size and determine the granularity of the block-cyclic distribution.
+
In the following the block-cyclic distribution of a matrix onto a Cartesian process grid with block sizes is displayed.
Block-Cyclic Distribution
-
Note that the odd number of columns of the local matrices owned by the processes P2, P5 and P8 accounts for not being an integral multiple of .
+
Note that the odd number of columns of the local matrices owned by the processes P2, P5 and P8 accounts for not being an integral multiple of .
The choice of the block sizes is a compromise between a sufficiently large size for efficient local/serial BLAS, but one that is also small enough to achieve good parallel load balance.
Below we show a strong scaling example of ScaLAPACKMatrix::invert() on up to 5 nodes each composed of two Intel Xeon 2660v2 IvyBridge sockets 2.20GHz, 10 cores/socket. Calculations are performed on square processor grids 1x1, 2x2, 3x3, 4x4, 5x5, 6x6, 7x7, 8x8, 9x9, 10x10.
@@ -626,7 +626,7 @@
Constructor for a rectangular matrix with n_rows and n_cols and distributed using the grid process_grid.
-
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
+
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
Constructor for a square matrix of size size, and distributed using the process grid in process_grid.
-
The parameter block_size is used for the block-cyclic distribution of the matrix. An identical block size is used for the rows and columns of the matrix. In general, it is recommended to use powers of , e.g. .
+
The parameter block_size is used for the block-cyclic distribution of the matrix. An identical block size is used for the rows and columns of the matrix. In general, it is recommended to use powers of , e.g. .
Constructor for a general rectangular matrix that is read from the file filename and distributed using the grid process_grid.
Loads the matrix from file filename using HDF5. In case that deal.II was built without HDF5 a call to this function will cause an exception to be thrown.
-
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
+
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
Initialize the rectangular matrix with n_rows and n_cols and distributed using the grid process_grid.
-
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
+
The parameters row_block_size and column_block_size are the block sizes used for the block-cyclic distribution of the matrix. In general, it is recommended to use powers of , e.g. .
Initialize the square matrix of size size and distributed using the grid process_grid.
-
The parameter block_size is used for the block-cyclic distribution of the matrix. An identical block size is used for the rows and columns of the matrix. In general, it is recommended to use powers of , e.g. .
+
The parameter block_size is used for the block-cyclic distribution of the matrix. An identical block size is used for the rows and columns of the matrix. In general, it is recommended to use powers of , e.g. .
We will denote this solution function described by this DoFHandler and vector object by where is a vector with just one component, and consequently is not shown in boldface. Then assume that we want this to be used as a boundary condition for a 2d problem at the line . Let's say that this line corresponds to boundary indicator 123. If we say that the 2d problem is associated with
We will denote this solution function described by this DoFHandler and vector object by where is a vector with just one component, and consequently is not shown in boldface. Then assume that we want this to be used as a boundary condition for a 2d problem at the line . Let's say that this line corresponds to boundary indicator 123. If we say that the 2d problem is associated with
The question here is what to use as the Function object that can be passed as third argument. It needs to be a Function<2> object, i.e., it receives a 2d input point and is supposed to return the value at that point. What we want it to do is to just take the component of the input point and evaluate the 1d solution at that point, knowing that at the boundary with indicator 123, the component of the input point must be zero. This all can be achieved via the following function object:
The question here is what to use as the Function object that can be passed as third argument. It needs to be a Function<2> object, i.e., it receives a 2d input point and is supposed to return the value at that point. What we want it to do is to just take the component of the input point and evaluate the 1d solution at that point, knowing that at the boundary with indicator 123, the component of the input point must be zero. This all can be achieved via the following function object:
/usr/share/doc/packages/dealii/doxygen/deal.II/classSolverBFGS.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverBFGS.html 2024-12-27 18:25:11.448891895 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverBFGS.html 2024-12-27 18:25:11.456891950 +0000
@@ -379,8 +379,8 @@
\]" src="form_2508.png"/>
starting from initial state x.
-
The function compute takes two arguments indicating the values of and of the gradient . When called, it needs to update the gradient at the given location and return the value of the function being minimized, i.e., .
+
The function compute takes two arguments indicating the values of and of the gradient . When called, it needs to update the gradient at the given location and return the value of the function being minimized, i.e., .
@@ -401,7 +401,7 @@
Connect a slot to perform a custom line-search.
-
Given the value of function f, the current value of unknown x, the gradient g and the search direction p, return the size of the step , and update x, g and f accordingly.
+
Given the value of function f, the current value of unknown x, the gradient g and the search direction p, return the size of the step , and update x, g and f accordingly.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSolverFIRE.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverFIRE.html 2024-12-27 18:25:11.492892197 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverFIRE.html 2024-12-27 18:25:11.496892225 +0000
@@ -209,10 +209,10 @@
FIRE (Fast Inertial Relaxation Engine) for minimization of (potentially non-linear) objective function , is a vector of variables ( is the number of variables of the objective function). Like all other solver classes, it can work on any kind of vector and matrix as long as they satisfy certain requirements (for the requirements on matrices and vectors in order to work with this class, see the documentation of the Solver base class). The type of the solution vector must be passed as template argument, and defaults to Vector<double>.
+class SolverFIRE< VectorType >
FIRE (Fast Inertial Relaxation Engine) for minimization of (potentially non-linear) objective function , is a vector of variables ( is the number of variables of the objective function). Like all other solver classes, it can work on any kind of vector and matrix as long as they satisfy certain requirements (for the requirements on matrices and vectors in order to work with this class, see the documentation of the Solver base class). The type of the solution vector must be passed as template argument, and defaults to Vector<double>.
FIRE is a damped dynamics method described in Structural Relaxation Made Simple by Bitzek et al. 2006, typically used to find stable equilibrium configurations of atomistic systems in computational material science. Starting from a given initial configuration of the atomistic system, the algorithm relies on inertia to obtain (nearest) configuration with least potential energy.
Notation:
-
The global vector of unknown variables: .
+
The global vector of unknown variables: .
Objective function: .
Rate of change of unknowns: .
Gradient of the objective function w.r.t unknowns: .
@@ -220,15 +220,15 @@
Initial guess of unknowns: .
Time step: .
-
Given initial values for , , , and along with a given mass matrix , FIRE algorithm is as follows,
+
Given initial values for , , , and along with a given mass matrix , FIRE algorithm is as follows,
Calculate and check for convergence ( ).
-
Update and using simple (forward) Euler integration step,
+
Update and using simple (forward) Euler integration step, , .
Calculate .
Set .
-
If and number of steps since was last negative is larger than certain value, then increase time step and decrease .
+
If and number of steps since was last negative is larger than certain value, then increase time step and decrease .
If , then decrease the time step, freeze the system i.e., and reset .
Return to 1.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSolverRichardson.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverRichardson.html 2024-12-27 18:25:11.528892444 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSolverRichardson.html 2024-12-27 18:25:11.532892472 +0000
@@ -440,7 +440,7 @@
const PreconditionerType &
preconditioner&#href_anchor"memdoc">
-
Solve for .
+
Solve for .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseDirectUMFPACK.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseDirectUMFPACK.html 2024-12-27 18:25:11.576892774 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseDirectUMFPACK.html 2024-12-27 18:25:11.580892801 +0000
@@ -590,7 +590,7 @@
The solution will be returned in place of the right hand side vector.
Parameters
-
[in,out]
rhs_and_solution
A vector that contains the right hand side of a linear system upon calling this function, and that contains the solution of the linear system after calling this function.
+
[in,out]
rhs_and_solution
A vector that contains the right hand side of a linear system upon calling this function, and that contains the solution of the linear system after calling this function.
[in]
transpose
If set to true, this function solves the linear instead of .
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseILU.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseILU.html 2024-12-27 18:25:11.668893406 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseILU.html 2024-12-27 18:25:11.668893406 +0000
@@ -1822,7 +1822,7 @@
-
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 SparsityPattern::symmetrize().
@@ -2074,7 +2074,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation, and for 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 complex-valued, but not mixed, for this function to make sense.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
@@ -2184,7 +2184,7 @@
Perform the matrix-matrix multiplication C = A * B, or, if an optional vector argument is given, C = A * diag(V) * B, where diag(V) defines a diagonal matrix with the vector entries.
This function assumes that the calling matrix A and the argument B have compatible sizes. By default, the output matrix C will be resized appropriately.
-
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
+
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
When setting rebuild_sparsity_pattern to true (i.e., leaving it at the default value), it is important to realize that the matrix C passed as first argument still has to be initialized with a sparsity pattern (either at the time of creation of the SparseMatrix object, or via the SparseMatrix::reinit() function). This is because we could create a sparsity pattern inside the current function, and then associate C with it, but there would be no way to transfer ownership of this sparsity pattern to anyone once the current function finishes. Consequently, the function requires that C be already associated with a sparsity pattern object, and this object is then reset to fit the product of A and B.
As a consequence of this, however, it is also important to realize that the sparsity pattern of C is modified and that this would render invalid all other SparseMatrix objects that happen to also use that sparsity pattern object.
@@ -2255,8 +2255,8 @@
-
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
@@ -2284,8 +2284,8 @@
-
Return the -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseLUDecomposition.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseLUDecomposition.html 2024-12-27 18:25:11.740893900 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseLUDecomposition.html 2024-12-27 18:25:11.744893928 +0000
@@ -1625,7 +1625,7 @@
-
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 SparsityPattern::symmetrize().
@@ -1970,7 +1970,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation, and for 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 complex-valued, but not mixed, for this function to make sense.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
@@ -2080,7 +2080,7 @@
Perform the matrix-matrix multiplication C = A * B, or, if an optional vector argument is given, C = A * diag(V) * B, where diag(V) defines a diagonal matrix with the vector entries.
This function assumes that the calling matrix A and the argument B have compatible sizes. By default, the output matrix C will be resized appropriately.
-
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
+
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
When setting rebuild_sparsity_pattern to true (i.e., leaving it at the default value), it is important to realize that the matrix C passed as first argument still has to be initialized with a sparsity pattern (either at the time of creation of the SparseMatrix object, or via the SparseMatrix::reinit() function). This is because we could create a sparsity pattern inside the current function, and then associate C with it, but there would be no way to transfer ownership of this sparsity pattern to anyone once the current function finishes. Consequently, the function requires that C be already associated with a sparsity pattern object, and this object is then reset to fit the product of A and B.
As a consequence of this, however, it is also important to realize that the sparsity pattern of C is modified and that this would render invalid all other SparseMatrix objects that happen to also use that sparsity pattern object.
@@ -2151,8 +2151,8 @@
-
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
@@ -2180,8 +2180,8 @@
-
Return the -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMIC.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMIC.html 2024-12-27 18:25:11.820894449 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMIC.html 2024-12-27 18:25:11.824894477 +0000
@@ -401,8 +401,8 @@
template<typename number>
class SparseMIC< number >
Implementation of the Modified Incomplete Cholesky (MIC(0)) preconditioner for symmetric matrices. This class conforms to the state and usage specification in SparseLUDecomposition.
The decomposition
-
Let a symmetric, positive-definite, sparse matrix be in the form , where is the diagonal part of and is a strictly lower triangular matrix. The MIC(0) decomposition of the matrix is defined by , where is a diagonal matrix defined by the condition .
+
Let a symmetric, positive-definite, sparse matrix be in the form , where is the diagonal part of and is a strictly lower triangular matrix. The MIC(0) decomposition of the matrix is defined by , where is a diagonal matrix defined by the condition .
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 SparsityPattern::symmetrize().
@@ -2143,7 +2143,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation, and for 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 complex-valued, but not mixed, for this function to make sense.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
@@ -2253,7 +2253,7 @@
Perform the matrix-matrix multiplication C = A * B, or, if an optional vector argument is given, C = A * diag(V) * B, where diag(V) defines a diagonal matrix with the vector entries.
This function assumes that the calling matrix A and the argument B have compatible sizes. By default, the output matrix C will be resized appropriately.
-
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
+
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
When setting rebuild_sparsity_pattern to true (i.e., leaving it at the default value), it is important to realize that the matrix C passed as first argument still has to be initialized with a sparsity pattern (either at the time of creation of the SparseMatrix object, or via the SparseMatrix::reinit() function). This is because we could create a sparsity pattern inside the current function, and then associate C with it, but there would be no way to transfer ownership of this sparsity pattern to anyone once the current function finishes. Consequently, the function requires that C be already associated with a sparsity pattern object, and this object is then reset to fit the product of A and B.
As a consequence of this, however, it is also important to realize that the sparsity pattern of C is modified and that this would render invalid all other SparseMatrix objects that happen to also use that sparsity pattern object.
@@ -2324,8 +2324,8 @@
-
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
@@ -2353,8 +2353,8 @@
-
Return the -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrix.html 2024-12-27 18:25:11.908895054 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrix.html 2024-12-27 18:25:11.916895109 +0000
@@ -1465,7 +1465,7 @@
-
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 SparsityPattern::symmetrize().
@@ -1825,7 +1825,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e. . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation, and for 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 complex-valued, but not mixed, for this function to make sense.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile).
Perform the matrix-matrix multiplication C = A * B, or, if an optional vector argument is given, C = A * diag(V) * B, where diag(V) defines a diagonal matrix with the vector entries.
This function assumes that the calling matrix A and the argument B have compatible sizes. By default, the output matrix C will be resized appropriately.
-
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
+
By default, i.e., if the optional argument rebuild_sparsity_pattern is true, the sparsity pattern of the matrix C will be changed to ensure that all entries that result from the product can be stored in . This is an expensive operation, and if there is a way to predict the sparsity pattern up front, you should probably build it yourself before calling this function with false as last argument. In this case, the rebuilding of the sparsity pattern is bypassed.
When setting rebuild_sparsity_pattern to true (i.e., leaving it at the default value), it is important to realize that the matrix C passed as first argument still has to be initialized with a sparsity pattern (either at the time of creation of the SparseMatrix object, or via the SparseMatrix::reinit() function). This is because we could create a sparsity pattern inside the current function, and then associate C with it, but there would be no way to transfer ownership of this sparsity pattern to anyone once the current function finishes. Consequently, the function requires that C be already associated with a sparsity pattern object, and this object is then reset to fit the product of A and B.
As a consequence of this, however, it is also important to realize that the sparsity pattern of C is modified and that this would render invalid all other SparseMatrix objects that happen to also use that sparsity pattern object.
@@ -1970,8 +1970,8 @@
-
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
+
Return the -norm of the matrix, that is , (max. sum of columns). This is the natural matrix norm that is compatible to the -norm for vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
@@ -1991,8 +1991,8 @@
-
Return the -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. -norm of the matrix, that is , (max. sum of rows). This is the natural matrix norm that is compatible to the -norm of vectors, i.e. . (cf. Haemmerlin-Hoffmann: Numerische Mathematik)
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixEZ.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixEZ.html 2024-12-27 18:25:11.984895575 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixEZ.html 2024-12-27 18:25:11.992895630 +0000
@@ -1219,7 +1219,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixIterators_1_1Iterator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixIterators_1_1Iterator.html 2024-12-27 18:25:12.028895878 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparseMatrixIterators_1_1Iterator.html 2024-12-27 18:25:12.028895878 +0000
@@ -156,7 +156,7 @@
The typical use for these iterators is to iterate over the elements of a sparse matrix or over the elements of individual rows. Note that there is no guarantee that the elements of a row are actually traversed in an order in which columns monotonically increase. See the documentation of the SparsityPattern class for more information.
The first template argument denotes the underlying numeric type, the second the constness of the matrix.
Since there is a specialization of this class for Constness=false, this class is for iterators to constant matrices.
-
Note
This class operates directly on the internal data structures of the SparsityPattern and SparseMatrix classes. As a consequence, some operations are cheap and some are not. In particular, it is cheap to access the column index and the value of an entry pointed to. On the other hand, it is expensive to access the row index (this requires operations for a matrix with row). As a consequence, when you design algorithms that use these iterators, it is common practice to not loop over all elements of a sparse matrix at once, but to have an outer loop over all rows and within this loop iterate over the elements of this row. This way, you only ever need to dereference the iterator to obtain the column indices and values whereas the (expensive) lookup of the row index can be avoided by using the loop index instead.
+
Note
This class operates directly on the internal data structures of the SparsityPattern and SparseMatrix classes. As a consequence, some operations are cheap and some are not. In particular, it is cheap to access the column index and the value of an entry pointed to. On the other hand, it is expensive to access the row index (this requires operations for a matrix with row). As a consequence, when you design algorithms that use these iterators, it is common practice to not loop over all elements of a sparse matrix at once, but to have an outer loop over all rows and within this loop iterate over the elements of this row. This way, you only ever need to dereference the iterator to obtain the column indices and values whereas the (expensive) lookup of the row index can be avoided by using the loop index instead.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPattern.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPattern.html 2024-12-27 18:25:12.076896207 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPattern.html 2024-12-27 18:25:12.080896235 +0000
@@ -1174,7 +1174,7 @@
-
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is , a diagonal matrix has bandwidth 0, and there are at most entries per row if the bandwidth is . The returned quantity is sometimes called "half
+
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is , a diagonal matrix has bandwidth 0, and there are at most entries per row if the bandwidth is . The returned quantity is sometimes called "half
bandwidth" in the literature.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPatternIterators_1_1Iterator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPatternIterators_1_1Iterator.html 2024-12-27 18:25:12.116896482 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSparsityPatternIterators_1_1Iterator.html 2024-12-27 18:25:12.120896509 +0000
@@ -177,7 +177,7 @@
Detailed Description
An iterator class for walking over the elements of a sparsity pattern.
The typical use for these iterators is to iterate over the elements of a sparsity pattern (or, since they also serve as the basis for iterating over the elements of an associated matrix, over the elements of a sparse matrix), or over the elements of individual rows. There is no guarantee that the elements of a row are actually traversed in an order in which column numbers monotonically increase. See the documentation of the SparsityPattern class for more information.
-
Note
This class operates directly on the internal data structures of the SparsityPattern class. As a consequence, some operations are cheap and some are not. In particular, it is cheap to access the column index of the sparsity pattern entry pointed to. On the other hand, it is expensive to access the row index (this requires operations for a matrix with row). As a consequence, when you design algorithms that use these iterators, it is common practice to not loop over all elements of a sparsity pattern at once, but to have an outer loop over all rows and within this loop iterate over the elements of this row. This way, you only ever need to dereference the iterator to obtain the column indices whereas the (expensive) lookup of the row index can be avoided by using the loop index instead.
+
Note
This class operates directly on the internal data structures of the SparsityPattern class. As a consequence, some operations are cheap and some are not. In particular, it is cheap to access the column index of the sparsity pattern entry pointed to. On the other hand, it is expensive to access the row index (this requires operations for a matrix with row). As a consequence, when you design algorithms that use these iterators, it is common practice to not loop over all elements of a sparsity pattern at once, but to have an outer loop over all rows and within this loop iterate over the elements of this row. This way, you only ever need to dereference the iterator to obtain the column indices whereas the (expensive) lookup of the row index can be avoided by using the loop index instead.
/usr/share/doc/packages/dealii/doxygen/deal.II/classSphericalManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSphericalManifold.html 2024-12-27 18:25:12.160896784 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSphericalManifold.html 2024-12-27 18:25:12.164896811 +0000
@@ -219,20 +219,20 @@
class SphericalManifold< dim, spacedim >
Manifold description for a spherical space coordinate system.
You can use this Manifold object to describe any sphere, circle, hypersphere or hyperdisc in two or three dimensions. This manifold can be used as a co-dimension one manifold descriptor of a spherical surface embedded in a higher dimensional space, or as a co-dimension zero manifold descriptor for a body with positive volume, provided that the center of the spherical space is excluded from the domain. An example for the use of this function would be in the description of a hyper-shell or hyper-ball geometry, for example after creating a coarse mesh using GridGenerator::hyper_ball(). (However, it is worth mentioning that generating a good mesh for a disk or ball is complicated and requires addition steps. See the "Possibilities for extensions" section of step-6 for an extensive discussion of how one would construct such meshes and what one needs to do for it.)
The two template arguments match the meaning of the two template arguments in Triangulation<dim, spacedim>, however this Manifold can be used to describe both thin and thick objects, and the behavior is identical when dim <= spacedim, i.e., the functionality of SphericalManifold<2,3> is identical to SphericalManifold<3,3>.
-
While PolarManifold reflects the usual notion of polar coordinates, it may not be suitable for domains that contain either the north or south poles. Consider for instance the pair of points and in polar coordinates (lying on the surface of a sphere with radius one, on a parallel at height ). In this case connecting the points with a straight line in polar coordinates would take the long road around the globe, without passing through the north pole.
+
While PolarManifold reflects the usual notion of polar coordinates, it may not be suitable for domains that contain either the north or south poles. Consider for instance the pair of points and in polar coordinates (lying on the surface of a sphere with radius one, on a parallel at height ). In this case connecting the points with a straight line in polar coordinates would take the long road around the globe, without passing through the north pole.
These two points would be connected (using a PolarManifold) by the curve
-
+\end{align*}" src="form_1525.png"/>
This curve is not a geodesic on the sphere, and it is not how we would connect those two points. A better curve, would be the one passing through the North pole:
-
+\]" src="form_1526.png"/>
-
where and for . Indeed, this is a geodesic, and it is the natural choice when connecting points on the surface of the sphere. In the examples above, the PolarManifold class implements the first way of connecting two points on the surface of a sphere, while SphericalManifold implements the second way, i.e., this Manifold connects points using geodesics. If more than two points are involved through a SphericalManifold::get_new_points() call, a so-called spherical average is used where the final point minimizes the weighted distance to all other points via geodesics.
+
where and for . Indeed, this is a geodesic, and it is the natural choice when connecting points on the surface of the sphere. In the examples above, the PolarManifold class implements the first way of connecting two points on the surface of a sphere, while SphericalManifold implements the second way, i.e., this Manifold connects points using geodesics. If more than two points are involved through a SphericalManifold::get_new_points() call, a so-called spherical average is used where the final point minimizes the weighted distance to all other points via geodesics.
In particular, this class implements a Manifold that joins any two points in space by first projecting them onto the surface of a sphere with unit radius, then connecting them with a geodesic, and finally rescaling the final radius so that the resulting one is the weighted average of the starting radii. This Manifold is identical to PolarManifold in dimension two, while for dimension three it returns points that are more uniformly distributed on the sphere, and it is invariant with respect to rotations of the coordinate system, therefore avoiding the problems that PolarManifold has at the poles. Notice, in particular, that computing tangent vectors at the poles with a PolarManifold is not well defined, while it is perfectly fine with this class.
For mathematical reasons, it is impossible to construct a unique map of a sphere using only geodesic curves, and therefore, using this class with MappingManifold is discouraged. If you use this Manifold to describe the geometry of a sphere, you should use MappingQ as the underlying mapping, and not MappingManifold.
This Manifold can be used only on geometries where a ball with finite radius is removed from the center. Indeed, the center is a singular point for this manifold, and if you try to connect two points across the center, they would travel on spherical coordinates, avoiding the center.
/usr/share/doc/packages/dealii/doxygen/deal.II/classStridedArrayView.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classStridedArrayView.html 2024-12-27 18:25:12.184896949 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classStridedArrayView.html 2024-12-27 18:25:12.188896976 +0000
@@ -287,7 +287,7 @@
-
Return a reference to the th element of the range represented by the current object.
+
Return a reference to the th element of the range represented by the current object.
This function is marked as const because it does not change the view object. It may however return a reference to a non-const 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/classSymmetricTensor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classSymmetricTensor.html 2024-12-27 18:25:12.268897526 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classSymmetricTensor.html 2024-12-27 18:25:12.272897553 +0000
@@ -318,7 +318,7 @@
template<int rank_, int dim, typename Number>
-class SymmetricTensor< rank_, dim, Number >
Provide a class that stores symmetric tensors of rank 2,4,... efficiently, i.e. only store those off-diagonal elements of the full tensor that are not redundant. For example, for symmetric tensors, this would be the elements 11, 22, and 12, while the element 21 is equal to the 12 element. Within this documentation, second order symmetric tensors are denoted as bold-faced upper-case Latin letters such as or bold-faced Greek letters such as , . The Cartesian coordinates of a second-order tensor such as are represented as where are indices ranging from 0 to dim-1.
+class SymmetricTensor< rank_, dim, Number >
Provide a class that stores symmetric tensors of rank 2,4,... efficiently, i.e. only store those off-diagonal elements of the full tensor that are not redundant. For example, for symmetric tensors, this would be the elements 11, 22, and 12, while the element 21 is equal to the 12 element. Within this documentation, second order symmetric tensors are denoted as bold-faced upper-case Latin letters such as or bold-faced Greek letters such as , . The Cartesian coordinates of a second-order tensor such as are represented as where are indices ranging from 0 to dim-1.
Using this class for symmetric tensors of rank 2 has advantages over matrices in many cases since the dimension is known to the compiler as well as the location of the data. It is therefore possible to produce far more efficient code than for matrices with runtime-dependent dimension. It is also more efficient than using the more general Tensor class, since fewer elements are stored, and the class automatically makes sure that the tensor represents a symmetric object.
For tensors of higher rank, the savings in storage are even higher. For example for the tensors of rank 4, only 36 instead of the full 81 entries have to be stored. These rank 4 tensors are denoted by blackboard-style upper-case Latin letters such as with components .
While the definition of a symmetric rank-2 tensor is obvious, tensors of rank 4 are considered symmetric if they are operators mapping symmetric rank-2 tensors onto symmetric rank-2 tensors. This so-called minor symmetry of the rank 4 tensor requires that for every set of four indices , the identity
-
This operator assigns a scalar to a tensor. To avoid confusion with what exactly it means to assign a scalar value to a tensor, zero is the only value allowed for d, allowing the intuitive notation to reset all elements of the tensor to zero.
+
This operator assigns a scalar to a tensor. To avoid confusion with what exactly it means to assign a scalar value to a tensor, zero is the only value allowed for d, allowing the intuitive notation to reset all elements of the tensor to zero.
@@ -909,8 +909,8 @@
-
Double contraction product between the present symmetric tensor and a tensor of rank 2. For example, if the present object is the symmetric rank-2 tensor and it is multiplied by another symmetric rank-2 tensor , then the result is the scalar-product double contraction . In this case, the return value evaluates to a single scalar. While it is possible to define other scalar products (and associated induced norms), this one seems to be the most appropriate one.
-
If the present object is a rank-4 tensor such as , then the result is a rank-2 tensor , i.e., the operation contracts over the last two indices of the present object and the indices of the argument, and the result is a tensor of rank 2 ( ).
+
Double contraction product between the present symmetric tensor and a tensor of rank 2. For example, if the present object is the symmetric rank-2 tensor and it is multiplied by another symmetric rank-2 tensor , then the result is the scalar-product double contraction . In this case, the return value evaluates to a single scalar. While it is possible to define other scalar products (and associated induced norms), this one seems to be the most appropriate one.
+
If the present object is a rank-4 tensor such as , then the result is a rank-2 tensor , i.e., the operation contracts over the last two indices of the present object and the indices of the argument, and the result is a tensor of rank 2 ( ).
Note that the multiplication operator for symmetric tensors is defined to be a double contraction over two indices, while it is defined as a single contraction over only one index for regular Tensor objects. For symmetric tensors it therefore acts in a way that is commonly denoted by a "colon multiplication" in the mathematical literature (the two dots of the colon suggesting that it is a contraction over two indices), which corresponds to a scalar product between tensors.
It is worth pointing out that this definition of operator* between symmetric tensors is different to how the (in general non-symmetric) Tensor class defines operator*, namely as the single-contraction product over the last index of the first operand and the first index of the second operand. For the double contraction of Tensor objects, you will need to use the double_contract() function.
To maintain at least a modicum of resemblance between the interfaces of Tensor and SymmetricTensor, there are also global functions double_contract() for symmetric tensors that then do the same work as this operator. However, rather than returning the result as a return value, they write it into the first argument to the function in the same way as the corresponding functions for the Tensor class do things.
@@ -1254,7 +1254,7 @@
-
The opposite of the previous function: given an index in the unrolled form of the tensor, return what set of indices (for rank-2 tensors) or (for rank-4 tensors) corresponds to it.
+
The opposite of the previous function: given an index in the unrolled form of the tensor, return what set of indices (for rank-2 tensors) or (for rank-4 tensors) corresponds to it.
For the kind of arguments to this function, i.e., a symmetric rank-2 tensor of size 2, the result is (counting indices starting at one) . As expected, for the symmetric tensors this function handles, this equals the determinant of the tensor. (This is so because for symmetric tensors, there really are only two invariants, so the second and third invariant are the same; the determinant is the third invariant.)
+ = A_{11} A_{22} - A_{12}^2$" src="form_830.png"/>. As expected, for the symmetric tensors this function handles, this equals the determinant of the tensor. (This is so because for symmetric tensors, there really are only two invariants, so the second and third invariant are the same; the determinant is the third invariant.)
The algorithm employed here determines the eigenvalues by computing the roots of the characteristic polynomial. In the case that there exists a common root (the eigenvalues are equal), the computation is subject to round-off errors of order . As an alternative, the eigenvectors() function provides a more robust, but costly, method to compute the eigenvalues of a symmetric tensor.
@@ -2602,7 +2602,7 @@
-
Compute the scalar product between two tensors of rank 2. In the current case where both arguments are symmetric tensors, this is equivalent to calling the expression A*B which uses SymmetricTensor::operator*().
+
Compute the scalar product between two tensors of rank 2. In the current case where both arguments are symmetric tensors, this is equivalent to calling the expression A*B which uses SymmetricTensor::operator*().
Compute the scalar product between two tensors of rank 2. We don't use operator* for this operation since the product between two tensors is usually assumed to be the contraction over the last index of the first tensor and the first index of the second tensor. For example, if B is a Tensor, calling A*B (instead of scalar_product(A,B)) provides .
+
Compute the scalar product between two tensors of rank 2. We don't use operator* for this operation since the product between two tensors is usually assumed to be the contraction over the last index of the first tensor and the first index of the second tensor. For example, if B is a Tensor, calling A*B (instead of scalar_product(A,B)) provides .
Compute the scalar product between two tensors of rank 2. We don't use operator* for this operation since the product between two tensors is usually assumed to be the contraction over the last index of the first tensor and the first index of the second tensor. For example, if A is a Tensor, calling A*B (instead of scalar_product(A,B)) provides .
+
Compute the scalar product between two tensors of rank 2. We don't use operator* for this operation since the product between two tensors is usually assumed to be the contraction over the last index of the first tensor and the first index of the second tensor. For example, if A is a Tensor, calling A*B (instead of scalar_product(A,B)) provides .
The dot product (single contraction) for tensors: Return a tensor of rank that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
- that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
+
+\]" src="form_863.png"/>
Note
As one operand is a Tensor, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for SymmetricTensor, which does the double contraction.
@@ -3006,13 +3006,13 @@
-
The dot product (single contraction) for tensors: Return a tensor of rank that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
- that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
+
+\]" src="form_863.png"/>
Note
As one operand is a Tensor, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for SymmetricTensor, which does the double contraction.
An integer denoting the number of independent components that fully describe a symmetric tensor. In space dimensions, this number equals for symmetric tensors of rank 2.
+
An integer denoting the number of independent components that fully describe a symmetric tensor. In space dimensions, this number equals for symmetric tensors of rank 2.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTableBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTableBase.html 2024-12-27 18:25:12.320897883 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTableBase.html 2024-12-27 18:25:12.324897910 +0000
@@ -245,7 +245,7 @@
In some way, this class is similar to the Tensor class, in that it templatizes on the number of dimensions. However, there are two major differences. The first is that the Tensor class stores only numeric values (as doubles), while the Table class stores arbitrary objects. The second is that the Tensor class has fixed sizes in each dimension, also given as a template argument, while this class can handle arbitrary and different sizes in each dimension.
This has two consequences. First, since the size is not known at compile time, it has to do explicit memory allocation. Second, the layout of individual elements is not known at compile time, so access is slower than for the Tensor class where the number of elements are their location is known at compile time and the compiler can optimize with this knowledge (for example when unrolling loops). On the other hand, this class is of course more flexible, for example when you want a two-dimensional table with the number of rows equal to the number of degrees of freedom on a cell, and the number of columns equal to the number of quadrature points. Both numbers may only be known at run-time, so a flexible table is needed here. Furthermore, you may want to store, say, the gradients of shape functions, so the data type is not a single scalar value, but a tensor itself.
Dealing with large data sets
-
The Table classes (derived from this class) are frequently used to store large data tables. A modest example is given in step-53 where we store a table of geographic elevation data for a region of Africa, and this data requires about 670 kB if memory; however, tables that store three- or more-dimensional data (say, information about the density, pressure, and temperature in the earth interior on a regular grid of (latitude, longitude, depth) points) can easily run into hundreds of megabytes or more. These tables are then often provided to classes such as InterpolatedTensorProductGridData or InterpolatedUniformGridData.
+
The Table classes (derived from this class) are frequently used to store large data tables. A modest example is given in step-53 where we store a table of geographic elevation data for a region of Africa, and this data requires about 670 kB if memory; however, tables that store three- or more-dimensional data (say, information about the density, pressure, and temperature in the earth interior on a regular grid of (latitude, longitude, depth) points) can easily run into hundreds of megabytes or more. These tables are then often provided to classes such as InterpolatedTensorProductGridData or InterpolatedUniformGridData.
If you need to load such tables on single-processor (or multi-threaded) jobs, then there is nothing you can do about the size of these tables: The table just has to fit into memory. But, if your program is parallelized via MPI, then a typical first implementation would create a table object on every process and fill it on every MPI process by reading the data from a file. This is inefficient from two perspectives:
You will have a lot of processes that are all trying to read from the same file at the same time.
In most cases, the data stored on every process is the same, and while every process needs to be able to read from a table, it is not necessary that every process stores its own table: All MPI processes that happen to be located on the same machine might as well store only one copy and make it available to each other via shared memory; in this model, only one MPI process per machine needs to store the data, and all other processes could then access it.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTableHandler.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTableHandler.html 2024-12-27 18:25:12.364898185 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTableHandler.html 2024-12-27 18:25:12.364898185 +0000
@@ -213,7 +213,7 @@
Two (or more) columns may be merged into a "supercolumn" by twice (or multiple) calling add_column_to_supercolumn(), see there. Additionally there is a function to set for each column the precision of the output of numbers, and there are several functions to prescribe the format and the captions the columns are written with in tex mode.
A detailed explanation of this class is also given in the step-13 tutorial program.
Example
-
This is a simple example demonstrating the usage of this class. The first column includes the numbers , the second , the third , where the second and third columns are merged into one supercolumn with the superkey squares and roots. Additionally the first column is aligned to the right (the default was centered) and the precision of the square roots are set to be 6 (instead of 4 as default).
+
This is a simple example demonstrating the usage of this class. The first column includes the numbers , the second , the third , where the second and third columns are merged into one supercolumn with the superkey squares and roots. Additionally the first column is aligned to the right (the default was centered) and the precision of the square roots are set to be 6 (instead of 4 as default).
When generating output, TableHandler expects that all columns have the exact same number of elements in it so that the result is in fact a table. This assumes that in each of the iterations (time steps, nonlinear iterations, etc) you fill every single column. On the other hand, this may not always be what you want to do. For example, it could be that the function that computes the nonlinear residual is only called every few time steps; or, a function computing statistics of the mesh is only called whenever the mesh is in fact refined. In these cases, the add_value() function will be called less often for some columns and the column would therefore have fewer elements; furthermore, these elements would not be aligned with the rows that contain the other data elements that were produced during this iteration. An entirely different scenario is that the table is filled and at a later time we use the data in there to compute the elements of other rows; the ConvergenceTable class does something like this.
To support both scenarios, the TableHandler class has a property called auto-fill mode. By default, auto-fill mode is off, but it can be enabled by calling set_auto_fill_mode(). If auto-fill mode is enabled we use the following algorithm:
-
When calling add_value(key, value), we count the number of elements in the column corresponding to key. Let's call this number .
-
We also determine the maximal number of elements in the other columns; call it .
-
If then we add copies of the object T() to this column. Here, T is the data type of the given value. For example, if T is a numeric type, then T() is the number zero; if T is std::string, then T() is the empty string "".
+
When calling add_value(key, value), we count the number of elements in the column corresponding to key. Let's call this number .
+
We also determine the maximal number of elements in the other columns; call it .
+
If then we add copies of the object T() to this column. Here, T is the data type of the given value. For example, if T is a numeric type, then T() is the number zero; if T is std::string, then T() is the empty string "".
Add the given value to this column.
Padding the column with default elements makes sure that after the addition the column has as many entries as the longest other column. In other words, if we have skipped previous invocations of add_value() for a given key, then the padding will enter default values into this column.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTensor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTensor.html 2024-12-27 18:25:12.428898624 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTensor.html 2024-12-27 18:25:12.432898652 +0000
@@ -281,13 +281,13 @@
class Tensor< rank_, dim, Number >
A general tensor class with an arbitrary rank, i.e. with an arbitrary number of indices. The Tensor class provides an indexing operator and a bit of infrastructure, but most functionality is recursively handed down to tensors of rank 1 or put into external templated functions, e.g. the contract family.
The rank of a tensor specifies which types of physical quantities it can represent:
-A rank-0 tensor is a scalar that can store quantities such as temperature or pressure. These scalar quantities are shown in this documentation as simple lower-case Latin letters e.g. .
+A rank-0 tensor is a scalar that can store quantities such as temperature or pressure. These scalar quantities are shown in this documentation as simple lower-case Latin letters e.g. .
-A rank-1 tensor is a vector with dim components and it can represent vector quantities such as velocity, displacement, electric field, etc. They can also describe the gradient of a scalar field. The notation used for rank-1 tensors is bold-faced lower-case Latin letters e.g. . The components of a rank-1 tensor such as are represented as where is an index between 0 and dim-1.
+A rank-1 tensor is a vector with dim components and it can represent vector quantities such as velocity, displacement, electric field, etc. They can also describe the gradient of a scalar field. The notation used for rank-1 tensors is bold-faced lower-case Latin letters e.g. . The components of a rank-1 tensor such as are represented as where is an index between 0 and dim-1.
-A rank-2 tensor is a linear operator that can transform a vector into another vector. These tensors are similar to matrices with components. There is a related class SymmetricTensor<2,dim> for tensors of rank 2 whose elements are symmetric. Rank-2 tensors are usually denoted by bold-faced upper-case Latin letters such as or bold-faced Greek letters for example . The components of a rank 2 tensor such as are shown with two indices as . These tensors usually describe the gradients of vector fields (deformation gradient, velocity gradient, etc.) or Hessians of scalar fields. Additionally, mechanical stress tensors are rank-2 tensors that map the unit normal vectors of internal surfaces into local traction (force per unit area) vectors.
+A rank-2 tensor is a linear operator that can transform a vector into another vector. These tensors are similar to matrices with components. There is a related class SymmetricTensor<2,dim> for tensors of rank 2 whose elements are symmetric. Rank-2 tensors are usually denoted by bold-faced upper-case Latin letters such as or bold-faced Greek letters for example . The components of a rank 2 tensor such as are shown with two indices as . These tensors usually describe the gradients of vector fields (deformation gradient, velocity gradient, etc.) or Hessians of scalar fields. Additionally, mechanical stress tensors are rank-2 tensors that map the unit normal vectors of internal surfaces into local traction (force per unit area) vectors.
-Tensors with ranks higher than 2 are similarly defined in a consistent manner. They have components and the number of indices required to identify a component equals rank. For rank-4 tensors, a symmetric variant called SymmetricTensor<4,dim> exists.
+Tensors with ranks higher than 2 are similarly defined in a consistent manner. They have components and the number of indices required to identify a component equals rank. For rank-4 tensors, a symmetric variant called SymmetricTensor<4,dim> exists.
Using this tensor class for objects of rank 2 has advantages over matrices in many cases since the dimension is known to the compiler as well as the location of the data. It is therefore possible to produce far more efficient code than for matrices with runtime-dependent dimension. It also makes the code easier to read because of the semantic difference between a tensor (an object that relates to a coordinate system and has transformation properties with regard to coordinate rotations and transforms) and matrices (which we consider as operators on arbitrary vector spaces related to linear algebra things).
Template Parameters
@@ -1227,7 +1227,7 @@
-
Return an unrolled index in the range for the element of the tensor indexed by the argument to the function.
+
Return an unrolled index in the range for the element of the tensor indexed by the argument to the function.
@@ -1255,7 +1255,7 @@
-
Opposite of component_to_unrolled_index: For an index in the range , return which set of indices it would correspond to.
+
Opposite of component_to_unrolled_index: For an index in the range , return which set of indices it would correspond to.
@@ -1891,11 +1891,11 @@
Entrywise multiplication of two tensor objects of general rank.
The dot product (single contraction) for tensors. This function return a tensor of rank that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
- that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:
+
+\]" src="form_863.png"/>
Note
For the Tensor class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for SymmetricTensor, for which the corresponding operator*() performs a double contraction. The origin of the difference in how operator*() is implemented between Tensor and SymmetricTensor is that for the former, the product between two Tensor objects of same rank and dimension results in another Tensor object – that it, operator*() corresponds to the multiplicative group action within the group of tensors. On the other hand, there is no corresponding multiplicative group action with the set of symmetric tensors because, in general, the product of two symmetric tensors is a nonsymmetric tensor. As a consequence, for a mathematician, it is clear that operator*() for symmetric tensors must have a different meaning: namely the dot or scalar product that maps two symmetric tensors of rank 2 to a scalar. This corresponds to the double-dot (colon) operator whose meaning is then extended to the product of any two even-ranked symmetric tensors.
-In case the contraction yields a tensor of rank 0, that is, if rank_1==rank_2==1, then a scalar number is returned as an unwrapped number type. Return the norm of the given rank-2 tensor, where (maximum of the sums over columns).
+In case the contraction yields a tensor of rank 0, that is, if rank_1==rank_2==1, then a scalar number is returned as an unwrapped number type. Return the norm of the given rank-2 tensor, where (maximum of the sums over columns).
/usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductManifold.html 2024-12-27 18:25:12.484899009 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductManifold.html 2024-12-27 18:25:12.488899036 +0000
@@ -233,7 +233,7 @@
Detailed Description
template<int dim, int dim_A, int spacedim_A, int chartdim_A, int dim_B, int spacedim_B, int chartdim_B>
class TensorProductManifold< dim, dim_A, spacedim_A, chartdim_A, dim_B, spacedim_B, chartdim_B >
This manifold will combine the ChartManifolds A and B given in the constructor to form a new ChartManifold by building the tensor product . The first spacedim_A dimensions in the real space and the first chartdim_A dimensions of the chart will be given by manifold A, while the remaining coordinates are given by B. The manifold is to be used by a Triangulation<dim, space_dim_A+space_dim_B>.
+
This manifold will combine the ChartManifolds A and B given in the constructor to form a new ChartManifold by building the tensor product . The first spacedim_A dimensions in the real space and the first chartdim_A dimensions of the chart will be given by manifold A, while the remaining coordinates are given by B. The manifold is to be used by a Triangulation<dim, space_dim_A+space_dim_B>.
An example usage would be the combination of a SphericalManifold with space dimension 2 and a FlatManifold with space dimension 1 to form a cylindrical manifold.
pull_back(), push_forward(), and push_forward_gradient() are implemented by splitting the input argument into inputs for A and B according to the given dimensions and applying the corresponding operations before concatenating the result.
Note
The dimension arguments dim_A and dim_B are not used.
@@ -605,24 +605,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductMatrixSymmetricSum.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductMatrixSymmetricSum.html 2024-12-27 18:25:12.524899283 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTensorProductMatrixSymmetricSum.html 2024-12-27 18:25:12.528899311 +0000
@@ -174,7 +174,7 @@
M_1 \otimes A_0
\end{align*}" src="form_2024.png"/>
-
in 3d. The typical application setting is a discretization of the Laplacian on a Cartesian (axis-aligned) geometry, where it can be exactly represented by the Kronecker or tensor product of a 1d mass matrix and a 1d Laplace matrix in each tensor direction (due to symmetry and are the same in each dimension). The dimension of the resulting class is the product of the one-dimensional matrices.
+
in 3d. The typical application setting is a discretization of the Laplacian on a Cartesian (axis-aligned) geometry, where it can be exactly represented by the Kronecker or tensor product of a 1d mass matrix and a 1d Laplace matrix in each tensor direction (due to symmetry and are the same in each dimension). The dimension of the resulting class is the product of the one-dimensional matrices.
This class implements two basic operations, namely the usual multiplication by a vector and the inverse. For both operations, fast tensorial techniques can be applied that implement the operator evaluation in arithmetic operations, considerably less than for the naive forward transformation and for setting up the inverse of .
Interestingly, the exact inverse of the matrix can be found through tensor products due to 1964's work by Lynch et al. [Lynch1964],
Manifold description for the surface of a Torus in three dimensions. The Torus is assumed to be in the x-z plane. The reference coordinate system is given by the angle around the y axis, the angle around the centerline of the torus, and the distance to the centerline (between 0 and 1).
+class TorusManifold< dim >
Manifold description for the surface of a Torus in three dimensions. The Torus is assumed to be in the x-z plane. The reference coordinate system is given by the angle around the y axis, the angle around the centerline of the torus, and the distance to the centerline (between 0 and 1).
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
+
Given a point in the chartdim dimensional Euclidean space, this method returns the derivatives of the function that maps from the chartdim-dimensional to the spacedim-dimensional space. In other words, it is a matrix of size .
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.
@@ -732,24 +732,24 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
-
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
-, is tangential to the geodesic that connects two points . See the documentation of the Manifold class and of Manifold::get_tangent_vector() for a more detailed description.
+
For the current class, we assume that this geodesic is the image under the push_forward() operation of a straight line of the pre-images of x1 and x2 (where pre-images are computed by pulling back the locations x1 and x2). In other words, if these preimages are , then the geodesic in preimage (the chartdim-dimensional Euclidean) space is
+
+\end{align*}" src="form_1516.png"/>
In image space, i.e., in the space in which we operate, this leads to the curve
-
+\end{align*}" src="form_1517.png"/>
-
What the current function is supposed to return is . By the chain rule, this is equal to
-. By the chain rule, this is equal to
+
+\end{align*}" src="form_1518.png"/>
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 of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
+
Thus, the computation of tangent vectors also requires the implementation of derivatives of the push-forward mapping. Here, is a chartdim-dimensional vector, and is a spacedim-times-chartdim-dimensional matrix. Consequently, and as desired, the operation results in a spacedim-dimensional vector.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTransfiniteInterpolationManifold.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTransfiniteInterpolationManifold.html 2024-12-27 18:25:12.628899997 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTransfiniteInterpolationManifold.html 2024-12-27 18:25:12.636900052 +0000
@@ -221,12 +221,12 @@
template<int dim, int spacedim = dim>
class TransfiniteInterpolationManifold< dim, spacedim >
A mapping class that extends curved boundary descriptions into the interior of the computational domain. The outer curved boundary description is assumed to be given by another manifold (e.g. a polar manifold on a circle). The mechanism to extend the boundary information is a so-called transfinite interpolation. The use of this class is discussed extensively in step-65.
The formula for extending such a description in 2d is, for example, described on Wikipedia. Given a point on the chart, the image of this point in real space is given by
-
+\end{align*}" src="form_1537.png"/>
where denote the four bounding vertices bounding the image space and are the four curves describing the lines of the cell. If a curved manifold is attached to any of these lines, the evaluation is done according to Manifold::get_new_point() with the two end points of the line and appropriate weight. In 3d, the generalization of this formula is implemented, creating a weighted sum of the vertices (positive contribution), the lines (negative), and the faces (positive contribution).
This manifold is usually attached to a coarse mesh and then places new points as a combination of the descriptions on the boundaries, weighted appropriately according to the position of the point in the original chart coordinates . This manifold should be preferred over setting only a curved manifold on the boundary of a mesh in most situations as it yields more uniform mesh distributions as the mesh is refined because it switches from a curved description to a straight description over all children of the initial coarse cell this manifold was attached to. This way, the curved nature of the manifold that is originally contained in one coarse mesh layer will be applied to more than one fine mesh layer once the mesh gets refined. Note that the mechanisms of TransfiniteInterpolationManifold are also built into the MappingQ class when only a surface of a cell is subject to a curved description, ensuring that even the default case without this manifold gets optimal convergence rates when applying curved boundary descriptions.
@@ -932,11 +932,11 @@
-
Return a vector that, at , is tangential to the geodesic that connects two points . The geodesic is the shortest line between these two points, where "shortest" is defined via a metric specific to a particular implementation of this class in a derived class. For example, in the case of a FlatManifold, the shortest line between two points is just the straight line, and in this case the tangent vector is just the difference . On the other hand, for a manifold that describes a surface embedded in a higher dimensional space (e.g., the surface of a sphere), then the tangent vector is tangential to the surface, and consequently may point in a different direction than the straight line that connects the two points.
-
While tangent vectors are often normalized to unit length, the vectors returned by this function are normalized as described in the introduction of this class. Specifically, if traces out the geodesic between the two points where and , then the returned vector must equal . In other words, the norm of the returned vector also encodes, in some sense, the length of the geodesic because a curve must move "faster" if the two points it connects between arguments and are farther apart.
-
The default implementation of this function approximates for a small value of , and the evaluation of is done by calling get_new_point(). If possible, derived classes should override this function by an implementation of the exact derivative.
+
Return a vector that, at , is tangential to the geodesic that connects two points . The geodesic is the shortest line between these two points, where "shortest" is defined via a metric specific to a particular implementation of this class in a derived class. For example, in the case of a FlatManifold, the shortest line between two points is just the straight line, and in this case the tangent vector is just the difference . On the other hand, for a manifold that describes a surface embedded in a higher dimensional space (e.g., the surface of a sphere), then the tangent vector is tangential to the surface, and consequently may point in a different direction than the straight line that connects the two points.
+
While tangent vectors are often normalized to unit length, the vectors returned by this function are normalized as described in the introduction of this class. Specifically, if traces out the geodesic between the two points where and , then the returned vector must equal . In other words, the norm of the returned vector also encodes, in some sense, the length of the geodesic because a curve must move "faster" if the two points it connects between arguments and are farther apart.
+
The default implementation of this function approximates for a small value of , and the evaluation of is done by calling get_new_point(). If possible, derived classes should override this function by an implementation of the exact derivative.
Parameters
x1
The first point that describes the geodesic, and the one at which the "direction" is to be evaluated.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTriaAccessor.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTriaAccessor.html 2024-12-27 18:25:12.704900519 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTriaAccessor.html 2024-12-27 18:25:12.708900547 +0000
@@ -338,7 +338,7 @@
Detailed Description
template<int structdim, int dim, int spacedim>
-class TriaAccessor< structdim, dim, spacedim >
A class that provides access to objects in a triangulation such as its vertices, sub-objects, children, geometric information, etc. This class represents objects of dimension structdim (i.e. 1 for lines, 2 for quads, 3 for hexes) in a triangulation of dimensionality dim (i.e. 1 for a triangulation of lines, 2 for a triangulation of quads, and 3 for a triangulation of hexes) that is embedded in a space of dimensionality spacedim (for spacedim==dim the triangulation represents a domain in , for spacedim>dim the triangulation is of a manifold embedded in a higher dimensional space).
+class TriaAccessor< structdim, dim, spacedim >
A class that provides access to objects in a triangulation such as its vertices, sub-objects, children, geometric information, etc. This class represents objects of dimension structdim (i.e. 1 for lines, 2 for quads, 3 for hexes) in a triangulation of dimensionality dim (i.e. 1 for a triangulation of lines, 2 for a triangulation of quads, and 3 for a triangulation of hexes) that is embedded in a space of dimensionality spacedim (for spacedim==dim the triangulation represents a domain in , for spacedim>dim the triangulation is of a manifold embedded in a higher dimensional space).
There is a specialization of this class for the case where structdim equals zero, i.e., for vertices of a triangulation.
This class is a specialization of TriaAccessor<structdim, dim, spacedim> for the case that structdim is zero and dim is one. This class represents vertices in a one-dimensional triangulation that is embedded in a space of dimensionality spacedim (for spacedim==dim==1 the triangulation represents a domain in , for spacedim>dim==1 the triangulation is of a manifold embedded in a higher dimensional space).
+class TriaAccessor< 0, 1, spacedim >
This class is a specialization of TriaAccessor<structdim, dim, spacedim> for the case that structdim is zero and dim is one. This class represents vertices in a one-dimensional triangulation that is embedded in a space of dimensionality spacedim (for spacedim==dim==1 the triangulation represents a domain in , for spacedim>dim==1 the triangulation is of a manifold embedded in a higher dimensional space).
The current specialization of the TriaAccessor<0,dim,spacedim> class for vertices of a one-dimensional triangulation exists since in the dim == 1 case vertices are also faces.
static unsigned int&#href_anchor"memItemRight" valign="bottom">quad_index (const unsigned int i)
&#href_anchor"details" id="details">
Detailed Description
template<int dim, int spacedim>
-class TriaAccessor< 0, dim, spacedim >
This class is a specialization of TriaAccessor<structdim, dim, spacedim> for the case that structdim is zero. This class represents vertices in a triangulation of dimensionality dim (i.e. 1 for a triangulation of lines, 2 for a triangulation of quads, and 3 for a triangulation of hexes) that is embedded in a space of dimensionality spacedim (for spacedim==dim the triangulation represents a domain in , for spacedim>dim the triangulation is of a manifold embedded in a higher dimensional space).
+class TriaAccessor< 0, dim, spacedim >
This class is a specialization of TriaAccessor<structdim, dim, spacedim> for the case that structdim is zero. This class represents vertices in a triangulation of dimensionality dim (i.e. 1 for a triangulation of lines, 2 for a triangulation of quads, and 3 for a triangulation of hexes) that is embedded in a space of dimensionality spacedim (for spacedim==dim the triangulation represents a domain in , for spacedim>dim the triangulation is of a manifold embedded in a higher dimensional space).
There is a further specialization of this class for the case that dim equals one, i.e., for vertices of a one-dimensional triangulation, since in that case vertices are also faces.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTriangulation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTriangulation.html 2024-12-27 18:25:12.960902277 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTriangulation.html 2024-12-27 18:25:12.968902332 +0000
@@ -1905,7 +1905,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -4880,7 +4880,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1BlockSparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1BlockSparseMatrix.html 2024-12-27 18:25:13.052902909 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1BlockSparseMatrix.html 2024-12-27 18:25:13.060902964 +0000
@@ -1016,7 +1016,7 @@
-
Matrix-vector multiplication: let with being this matrix. The vector types can be block vectors or non-block vectors (only if the matrix has only one row or column, respectively), and need to define TrilinosWrappers::SparseMatrix::vmult.
+
Matrix-vector multiplication: let with being this matrix. The vector types can be block vectors or non-block vectors (only if the matrix has only one row or column, respectively), and need to define TrilinosWrappers::SparseMatrix::vmult.
Adding Matrix-vector multiplication. Add on with being this matrix.
+
Adding Matrix-vector multiplication. Add on with being this matrix.
@@ -2634,7 +2634,7 @@
-
Matrix-vector multiplication: let with being this matrix.
+
Matrix-vector multiplication: let with being this matrix.
Due to problems with deriving template arguments between the block and non-block 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.
@@ -2742,7 +2742,7 @@
-
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
+
Matrix-vector multiplication: let with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block 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.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1BlockVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1BlockVector.html 2024-12-27 18:25:13.124903403 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1BlockVector.html 2024-12-27 18:25:13.128903431 +0000
@@ -1739,7 +1739,7 @@
-
: scalar product.
+
: scalar product.
@@ -1765,7 +1765,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
@@ -1817,7 +1817,7 @@
-
Return the -norm of the vector, i.e. the sum of the absolute values.
+
Return the -norm of the vector, i.e. the sum of the absolute values.
@@ -1843,7 +1843,7 @@
-
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
+
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
@@ -1869,7 +1869,7 @@
-
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
+
Return the maximum absolute value of the elements of this vector, which is the -norm of a vector.
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
@@ -2151,7 +2151,7 @@
-
. Addition of s to all components. Note that s is a scalar and not a vector.
+
. Addition of s to all components. Note that s is a scalar and not a vector.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1Vector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1Vector.html 2024-12-27 18:25:13.200903925 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1Vector.html 2024-12-27 18:25:13.208903980 +0000
@@ -1323,7 +1323,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
@@ -1395,7 +1395,7 @@
-
-norm of the vector. The sum of the absolute values.
+
-norm of the vector. The sum of the absolute values.
@@ -1413,7 +1413,7 @@
-
-norm of the vector. The square root of the sum of the squares of the elements.
+
-norm of the vector. The square root of the sum of the squares of the elements.
@@ -1431,7 +1431,7 @@
-
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
+
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
The reason this function exists is for compatibility with deal.II's own vector classes which can implement this functionality with less memory transfer. However, for Trilinos vectors such a combined operation is not natively supported and thus the cost is completely equivalent as calling the two methods separately.
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1NOXSolver.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1NOXSolver.html 2024-12-27 18:25:13.236904172 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1NOXSolver.html 2024-12-27 18:25:13.244904227 +0000
@@ -319,7 +319,7 @@
-
A function object that users should supply and that is intended to compute the residual .
+
A function object that users should supply and that is intended to compute the residual .
Note
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. NOX can not deal with "recoverable" errors for this callback, so if it throws an exception of type RecoverableUserCallbackError, then this exception is treated like any other exception.
A user function that applies the Jacobian to x and writes the result in y. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
+
A user function that applies the Jacobian to x and writes the result in y. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
Note
This function is optional and is used in the case of certain configurations. For instance, this function is required if the polynomial line search (NOX::LineSearch::Polynomial) is chosen, whereas for the full step case (NOX::LineSearch::FullStep) it won't be called.
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. NOX can not deal with "recoverable" errors for this callback, so if it throws an exception of type RecoverableUserCallbackError, then this exception is treated like any other exception.
@@ -403,7 +403,7 @@
-
A user function that applies the inverse of the Jacobian to y and writes the result in x. The parameter tolerance specifies the error reduction if an iterative solver is used in applying the inverse matrix. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
+
A user function that applies the inverse of the Jacobian to y and writes the result in x. The parameter tolerance specifies the error reduction if an iterative solver is used in applying the inverse matrix. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
Note
This function is optional and is used in the case of certain configurations.
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. NOX can deal with "recoverable" errors for this callback, if the NOX parameter "Newton/Rescue Bad Newton Solve" is set to true (which is, in fact, its default value). If this parameters is set to true, then exceptions of type RecoverableUserCallbackError are eaten for this callback and NOX can safely proceed with a recovery step. Exceptions of other types are still treated as "irrecoverable".
@@ -425,7 +425,7 @@
-
A user function that applies the inverse of the Jacobian to y, writes the result in x and returns the number of linear iterations the linear solver needed. The parameter tolerance species the error reduction if an iterative solver is used. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
+
A user function that applies the inverse of the Jacobian to y, writes the result in x and returns the number of linear iterations the linear solver needed. The parameter tolerance species the error reduction if an iterative solver is used. The Jacobian to be used (i.e., more precisely: the linearization point above) is the one computed when the setup_jacobian function was last called.
Note
This function is used if solve_with_jacobian is not provided. Its return value is compared again AdditionalFlags::threshold_n_linear_iterations; if it is larger, the preconditioner will be built before the next linear system is solved. The use of this approach is predicated on the idea that one can keep using a preconditioner built earlier as long as it is a good preconditioner for the matrix currently in use – where "good" is defined as leading to a number of iterations to solve linear systems less than the threshold given by the current variable.
This variable represents a user provided callback. See there for a description of how to deal with errors and other requirements and conventions. NOX can deal with "recoverable" errors for this callback, if the NOX parameter "Newton/Rescue Bad Newton Solve" is set to true (which is, in fact, its default value). If this parameters is set to true, then exceptions of type RecoverableUserCallbackError are eaten for this callback and NOX can safely proceed with a recovery step. Exceptions of other types are still treated as "irrecoverable".
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparseMatrix.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparseMatrix.html 2024-12-27 18:25:13.320904749 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparseMatrix.html 2024-12-27 18:25:13.324904777 +0000
@@ -2108,7 +2108,7 @@
-
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
+
Return the square of the norm of the vector with respect to the norm induced by this matrix, i.e., . This is useful, e.g. in the finite element context, where the norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the SparseMatrix class used in deal.II (i.e. the original one, not the Trilinos wrapper class) since Trilinos doesn't support this operation and needs a temporary vector.
The vector has to be initialized with the same IndexSet the matrix was initialized with.
/usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparsityPattern.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparsityPattern.html 2024-12-27 18:25:13.384905189 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classTrilinosWrappers_1_1SparsityPattern.html 2024-12-27 18:25:13.392905243 +0000
@@ -467,7 +467,7 @@
-
Generate a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally, too.
+
Generate a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally, too.
It is possible to specify the number of columns entries per row using the optional n_entries_per_row argument. However, this value does not need to be accurate or even given at all, since one does usually not have this kind of information before building the sparsity pattern (the usual case when the function DoFTools::make_sparsity_pattern() is called). The entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes. However, a good estimate will reduce the setup time of the sparsity pattern.
Initialize a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally.
+
Initialize a sparsity pattern that is completely stored locally, having rows and columns. The resulting matrix will be completely stored locally.
The number of columns entries per row is specified as the maximum number of entries argument. This does not need to be an accurate number since the entries are allocated dynamically in a similar manner as for the deal.II DynamicSparsityPattern classes, but a good estimate will reduce the setup time of the sparsity pattern.
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
+
Compute the bandwidth of the matrix represented by this structure. The bandwidth is the maximum of for which the index pair represents a nonzero entry of the matrix. Consequently, the maximum bandwidth a matrix can have is .
Constructor that takes the number of locally-owned degrees of freedom local_size and the number of ghost degrees of freedom ghost_size.
-
The local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively.
+
The local index range is translated to global indices in an ascending and one-to-one fashion, i.e., the indices of process sit exactly between the indices of the processes and , respectively.
Note
Setting the ghost_size variable to an appropriate value provides memory space for the ghost data in a vector's memory allocation as and allows access to it via local_element(). However, the associated global indices must be handled externally in this case.
/usr/share/doc/packages/dealii/doxygen/deal.II/classUtilities_1_1MPI_1_1ProcessGrid.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classUtilities_1_1MPI_1_1ProcessGrid.html 2024-12-27 18:25:13.480905848 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classUtilities_1_1MPI_1_1ProcessGrid.html 2024-12-27 18:25:13.480905848 +0000
@@ -238,8 +238,8 @@
Constructor for a process grid for a given mpi_communicator. In this case the process grid is heuristically chosen based on the dimensions and block-cyclic distribution of a target matrix provided in n_rows_matrix, n_columns_matrix, row_block_size and column_block_size.
-
The maximum number of MPI cores one can utilize is , where are the matrix dimension and are the block sizes and is the number of processes in the mpi_communicator. This function then creates a 2d processor grid assuming the ratio between number of process row and columns to be equal the ratio between matrix dimensions and .
-
For example, a square matrix with the block size and the mpi_communicator with 11 cores will result in the process grid.
+
The maximum number of MPI cores one can utilize is , where are the matrix dimension and are the block sizes and is the number of processes in the mpi_communicator. This function then creates a 2d processor grid assuming the ratio between number of process row and columns to be equal the ratio between matrix dimensions and .
+
For example, a square matrix with the block size and the mpi_communicator with 11 cores will result in the process grid.
/usr/share/doc/packages/dealii/doxygen/deal.II/classVector.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classVector.html 2024-12-27 18:25:13.600906672 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classVector.html 2024-12-27 18:25:13.604906699 +0000
@@ -1324,7 +1324,7 @@
Return the scalar product of two vectors. The return type is the underlying type of this vector, so the return type and the accuracy with which it the result is computed depend on the order of the arguments of this vector.
-
For complex vectors, the scalar product is implemented as .
+
For complex vectors, the scalar product is implemented as .
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
@@ -1345,7 +1345,7 @@
-
Return the square of the -norm.
+
Return the square of the -norm.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
@@ -1387,7 +1387,7 @@
-
-norm of the vector. The sum of the absolute values.
+
-norm of the vector. The sum of the absolute values.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
@@ -1408,7 +1408,7 @@
-
-norm of the vector. The square root of the sum of the squares of the elements.
+
-norm of the vector. The square root of the sum of the squares of the elements.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
@@ -1429,7 +1429,7 @@
-
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
+
-norm of the vector. The pth root of the sum of the pth powers of the absolute values of the elements.
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately. This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
-
For complex-valued vectors, the scalar product in the second step is implemented as .
+
For complex-valued vectors, the scalar product in the second step is implemented as .
Note
If deal.II is configured with threads, this operation will run multi-threaded by splitting the work into smaller chunks (assuming there is enough work to make this worthwhile). The algorithm uses pairwise summation with the same order of summation in every run, which gives fully repeatable results from one run to another.
/usr/share/doc/packages/dealii/doxygen/deal.II/classVectorFunctionFromScalarFunctionObject.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classVectorFunctionFromScalarFunctionObject.html 2024-12-27 18:25:13.660907084 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classVectorFunctionFromScalarFunctionObject.html 2024-12-27 18:25:13.660907084 +0000
@@ -235,7 +235,7 @@
Here, component_mask then represents a Function object that for every point returns the vector , i.e. a mask function that could, for example, be passed to VectorTools::integrate_difference(). This effect can also be achieved using the ComponentSelectFunction class but is obviously easily extended to functions that are non-constant in their one component.
+
Here, component_mask then represents a Function object that for every point returns the vector , i.e. a mask function that could, for example, be passed to VectorTools::integrate_difference(). This effect can also be achieved using the ComponentSelectFunction class but is obviously easily extended to functions that are non-constant in their one component.
/usr/share/doc/packages/dealii/doxygen/deal.II/classhp_1_1FECollection.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classhp_1_1FECollection.html 2024-12-27 18:25:13.720907496 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classhp_1_1FECollection.html 2024-12-27 18:25:13.724907523 +0000
@@ -1336,7 +1336,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.
-
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
@@ -1432,7 +1432,7 @@
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.
-
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
+
Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/classinternal_1_1MappingQImplementation_1_1InverseQuadraticApproximation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classinternal_1_1MappingQImplementation_1_1InverseQuadraticApproximation.html 2024-12-27 18:25:13.748907688 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classinternal_1_1MappingQImplementation_1_1InverseQuadraticApproximation.html 2024-12-27 18:25:13.752907715 +0000
@@ -179,7 +179,7 @@
The location of the support points in reference coordinates that map to the mapping support points in real space by a polynomial map.
+
unit_support_points
The location of the support points in reference coordinates that map to the mapping support points in real space by a polynomial map.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1DistributedTriangulationBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1DistributedTriangulationBase.html 2024-12-27 18:25:13.900908732 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1DistributedTriangulationBase.html 2024-12-27 18:25:13.908908787 +0000
@@ -1857,7 +1857,7 @@
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -2424,7 +2424,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -7022,7 +7022,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1TriangulationBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1TriangulationBase.html 2024-12-27 18:25:14.068909885 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1TriangulationBase.html 2024-12-27 18:25:14.072909913 +0000
@@ -1766,7 +1766,7 @@
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -2380,7 +2380,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -6999,7 +6999,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation.html 2024-12-27 18:25:14.244911094 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation.html 2024-12-27 18:25:14.248911121 +0000
@@ -2077,7 +2077,7 @@
-
Return a permutation vector for the order the coarse cells are handed off to p4est. For example the value of the th element in this vector is the index of the deal.II coarse cell (counting from begin(0)) that corresponds to the th tree managed by p4est.
+
Return a permutation vector for the order the coarse cells are handed off to p4est. For example the value of the th element in this vector is the index of the deal.II coarse cell (counting from begin(0)) that corresponds to the th tree managed by p4est.
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -3420,7 +3420,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -7753,7 +7753,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation_3_011_00_01spacedim_01_4.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:14.420912302 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1distributed_1_1Triangulation_3_011_00_01spacedim_01_4.html 2024-12-27 18:25:14.428912357 +0000
@@ -2242,7 +2242,7 @@
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -2813,7 +2813,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -7298,7 +7298,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1fullydistributed_1_1Triangulation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1fullydistributed_1_1Triangulation.html 2024-12-27 18:25:14.596913511 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1fullydistributed_1_1Triangulation.html 2024-12-27 18:25:14.604913566 +0000
@@ -2392,7 +2392,7 @@
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -2896,7 +2896,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -7230,7 +7230,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1shared_1_1Triangulation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1shared_1_1Triangulation.html 2024-12-27 18:25:14.768914692 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classparallel_1_1shared_1_1Triangulation.html 2024-12-27 18:25:14.768914692 +0000
@@ -2178,7 +2178,7 @@
When vertices have been moved locally, for example using code like
cell->vertex(0) = new_location;
then this function can be used to update the location of vertices between MPI processes.
-
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
+
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor move those vertices that are adjacent to cells whose owners include processor but no other processor with ; in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
@@ -2666,7 +2666,7 @@
-
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
+
Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of .
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.
@@ -7199,7 +7199,7 @@
-
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
+
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for no level argument must be given.
Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
/usr/share/doc/packages/dealii/doxygen/deal.II/deprecated.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/deprecated.html 2024-12-27 18:25:14.812914994 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/deprecated.html 2024-12-27 18:25:14.816915021 +0000
@@ -147,9 +147,9 @@
This function predates deal.II's use of manifolds and use of cell-local transfinite interpolation to place new points and is no longer necessary. See Manifolds::get_default_points_and_weights() for more information.
+
This function predates deal.II's use of manifolds and use of cell-local transfinite interpolation to place new points and is no longer necessary. See Manifolds::get_default_points_and_weights() for more information.
Member GridTools::rotate (const double angle, const unsigned int axis, Triangulation< dim, 3 > &triangulation)
This function is only kept for backward compatibility and has no meaning any more. ParticleAccessors always use the property pool of the owning particle handler.
This function suggests that the elements of a SymmetricTensor object are stored as a contiguous array, but this is not in fact true and one should not pretend that this so. As a consequence, this function is deprecated.
Member XDMFEntry::XDMFEntry (const std::string &filename, const double time, const std::uint64_t nodes, const std::uint64_t cells, const unsigned int dim)
/usr/share/doc/packages/dealii/doxygen/deal.II/derivative__form_8h.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/derivative__form_8h.html 2024-12-27 18:25:14.848915241 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/derivative__form_8h.html 2024-12-27 18:25:14.848915241 +0000
@@ -198,7 +198,7 @@
-
One of the uses of DerivativeForm is to apply it as a linear transformation. This function returns , which approximates the change in when is changed by the amount
+
One of the uses of DerivativeForm is to apply it as a linear transformation. This function returns , which approximates the change in when is changed by the amount
-
Similar to the previous apply_transformation(). In matrix notation, it computes . Moreover, the result of this operation can be interpreted as a metric tensor in which corresponds to the Euclidean metric tensor in . For every pair of vectors , we have:
+
Similar to the previous apply_transformation(). In matrix notation, it computes . Moreover, the result of this operation can be interpreted as a metric tensor in which corresponds to the Euclidean metric tensor in . For every pair of vectors , we have:
Quadrature coupling options when assembling quadrature formulas for double integrals.
When computing the approximation of double integrals of the form
-
+\]" src="form_1087.png"/>
-
where and are two arbitrary sets (cells, faces, edges, or any combination thereof), and is a (possibly singular) coupling kernel, one needs to combine quadrature formulas from two different FEValuesBase objects.
+
where and are two arbitrary sets (cells, faces, edges, or any combination thereof), and is a (possibly singular) coupling kernel, one needs to combine quadrature formulas from two different FEValuesBase objects.
This enum class provides a way to specify how the quadrature points and weights should be combined. In general, the two FEValuesBase objects provide different quadrature rules, and these can be interpreted in different ways, depending on the kernel function that is being integrated, and on how the two quadrature rules were constructed.
This enum is used in the constructor of FECouplingValues to specify how to interpret and manipulate the quadrature points and weights of the two FEValuesBase objects.
@@ -217,11 +217,11 @@
DoF coupling options when assembling double integrals.
When computing the approximation of double integrals of the form
-
+\]" src="form_1090.png"/>
-
where and are two arbitrary sets (cells, faces, edges, or any combination thereof), and is a (possibly singular) coupling kernel, one may want to combine degrees from two different FEValuesBase objects (i.e., basis functions and in the examples above).
+
where and are two arbitrary sets (cells, faces, edges, or any combination thereof), and is a (possibly singular) coupling kernel, one may want to combine degrees from two different FEValuesBase objects (i.e., basis functions and in the examples above).
This enum class provides a way to specify how the degrees of freedom should be combined. There are two cases of interest:
the two FEValuesBase objects refer to different DoFHandlers
@@ -230,14 +230,14 @@
In the first case, one usually treats the two sets of degrees of freedom as independent of each other, and the resulting matrix is generally rectangular.
In the second case, one may choose to treat the two sets of degrees of freedom either as independent or to group them together. A similar approach is used in the FEInterfaceValues class, where the degrees of freedom of the two FEValuesBase objects are grouped together, in a contiguous way, so that the resulting basis functions are interpreted in the following way:
-
+\]" src="form_1093.png"/>
-
where is the first basis function with index and are the number of local dofs on the first and second FEValuesBase objects.
+
where is the first basis function with index and are the number of local dofs on the first and second FEValuesBase objects.
This enum is used in the constructor of FECouplingValues to specify how to interpret and manipulate the local dof indices of the two FEValuesBase objects.
Enumerator
independent&#href_anchor"fielddoc">
The FEValuesBase objects may have different dof indices, possibly indexing different DoFHandler objects, and we are interested in assembling a generally rectangular matrix, where there is no relationship between the two index spaces.
/usr/share/doc/packages/dealii/doxygen/deal.II/fe__remote__evaluation_8h_source.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/fe__remote__evaluation_8h_source.html 2024-12-27 18:25:14.952915955 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/fe__remote__evaluation_8h_source.html 2024-12-27 18:25:14.960916010 +0000
@@ -949,7 +949,7 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/group__CPP11.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__CPP11.html 2024-12-27 18:25:15.004916312 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__CPP11.html 2024-12-27 18:25:15.008916339 +0000
@@ -185,7 +185,7 @@
The macro DEAL_II_CONSTEXPR expands to constexpr if the compiler supports enough constexpr features (such as loops). If the compiler does not then this macro expands to nothing.
Functions declared as constexpr can be evaluated at compile time. Hence code like
assuming A is declared with the constexpr specifier, will typically result in compile-time constants. This example shows the performance gains of using constexpr because here we performed an operation with complexity during compile time, avoiding any runtime cost.
+
assuming A is declared with the constexpr specifier, will typically result in compile-time constants. This example shows the performance gains of using constexpr because here we performed an operation with complexity during compile time, avoiding any runtime cost.
where these two member functions perform one step (or the transpose of such a step) of the smoothing scheme. In other words, the operations performed by these functions are and .
+
where these two member functions perform one step (or the transpose of such a step) of the smoothing scheme. In other words, the operations performed by these functions are and .
SparsityPatternType
/usr/share/doc/packages/dealii/doxygen/deal.II/group__LAOperators.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__LAOperators.html 2024-12-27 18:25:15.408919086 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__LAOperators.html 2024-12-27 18:25:15.416919140 +0000
@@ -337,7 +337,7 @@
std::function<void(Domain &, const Range &)> Tvmult;
std::function<void(Domain &, const Range &)> Tvmult_add;
Thus, such an object can be used as a matrix object in all iterative solver classes, either as a matrix object, or as preconditioner.
-
The big advantage of the LinearOperator class is that it provides syntactic sugar for complex matrix-vector operations. As an example consider the operation , where , and denote (possibly different) SparseMatrix objects. In order to construct a LinearOperatorop that performs above computation when applied on a vector, one can write:
The big advantage of the LinearOperator class is that it provides syntactic sugar for complex matrix-vector operations. As an example consider the operation , where , and denote (possibly different) SparseMatrix objects. In order to construct a LinearOperatorop that performs above computation when applied on a vector, one can write:
Create a PackagedOperation object from a LinearOperator and a reference to a vector u of the Range space. The object stores the PackagedOperation (in matrix notation). return (return_add) are implemented with Tvmult(__1,u) (Tvmult_add(__1,u)).
+
Create a PackagedOperation object from a LinearOperator and a reference to a vector u of the Range space. The object stores the PackagedOperation (in matrix notation). return (return_add) are implemented with Tvmult(__1,u) (Tvmult_add(__1,u)).
The PackagedOperation object that is created stores a reference to u. Thus, the vector must remain a valid reference for the whole lifetime of the PackagedOperation object. All changes made on u after the creation of the PackagedOperation object are reflected by the operator object.
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:
-
+\end{eqnarray*}" src="form_1940.png"/>
-
where represent general subblocks of the matrix and, similarly, general subvectors of are given by .
+
where represent general subblocks of the matrix and, similarly, general subvectors of are given by .
This is equivalent to the following two statements:
-
+\end{eqnarray*}" src="form_1945.png"/>
-
Assuming that are both square and invertible, we could then perform one of two possible substitutions,
- are both square and invertible, we could then perform one of two possible substitutions,
+
+\end{eqnarray*}" src="form_1947.png"/>
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)
-
+\end{eqnarray*}" src="form_1948.png"/>
This leads to the result
-
+\]" src="form_1949.png"/>
-
with being the Schur complement and the modified right-hand side vector arising from the condensation step. Note that for this choice of , submatrix need not be invertible and may thus be the null matrix. Ideally should be well-conditioned.
-
So for any arbitrary vector , the Schur complement performs the following operation:
- being the Schur complement and the modified right-hand side vector arising from the condensation step. Note that for this choice of , submatrix need not be invertible and may thus be the null matrix. Ideally should be well-conditioned.
+
So for any arbitrary vector , the Schur complement performs the following operation:
+
+\]" src="form_1956.png"/>
A typical set of steps needed the solve a linear system (1),(2) would be:
Define iterative inverse matrix such that (6) holds. It is necessary to use a solver with a preconditioner to compute the approximate inverse operation of since we never compute directly, but rather the result of its operation. To achieve this, one may again use the inverse_operator() in conjunction with the Schur complement that we've just constructed. Observe that the both and its preconditioner operate over the same space as .
Define iterative inverse matrix such that (6) holds. It is necessary to use a solver with a preconditioner to compute the approximate inverse operation of since we never compute directly, but rather the result of its operation. To achieve this, one may again use the inverse_operator() in conjunction with the Schur complement that we've just constructed. Observe that the both and its preconditioner operate over the same space as .
In the above example, the preconditioner for was defined as the preconditioner for , which is valid since they operate on the same space. However, if and are too dissimilar, then this may lead to a large number of solver iterations as is not a good approximation for .
-
A better preconditioner in such a case would be one that provides a more representative approximation for . One approach is shown in step-22, where is the null matrix and the preconditioner for is derived from the mass matrix over this space.
-
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for wherein expensive operation, namely , is approximated. Thereafter we construct the approximate inverse operator which is then used as the preconditioner for computing .
// Construction of approximate inverse of Schur complement
+
In the above example, the preconditioner for was defined as the preconditioner for , which is valid since they operate on the same space. However, if and are too dissimilar, then this may lead to a large number of solver iterations as is not a good approximation for .
+
A better preconditioner in such a case would be one that provides a more representative approximation for . One approach is shown in step-22, where is the null matrix and the preconditioner for is derived from the mass matrix over this space.
+
From another viewpoint, a similar result can be achieved by first constructing an object that represents an approximation for wherein expensive operation, namely , is approximated. Thereafter we construct the approximate inverse operator which is then used as the preconditioner for computing .
// Construction of approximate inverse of Schur complement
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 which acts only as the preconditioner for . Furthermore, the preconditioner to , which in this example is , should ideally be computationally inexpensive.
+
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 which acts only as the preconditioner for . Furthermore, the preconditioner to , which in this example is , should ideally be computationally inexpensive.
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 test-suite, such as tests/lac/schur_complement_01.cc. The solution of a multi-component problem (namely step-22) using the schur_complement can be found in tests/lac/schur_complement_03.cc.
this operation performs the pre-processing (condensation) step on the RHS subvector g so that the Schur complement can be used to solve this system of equations. More specifically, it produces an object that represents the condensed form of the subvector g, namely
this operation performs the post-processing step of the Schur complement to solve for the second subvector x once subvector y is known, with the result that
/usr/share/doc/packages/dealii/doxygen/deal.II/group__UpdateFlags.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__UpdateFlags.html 2024-12-27 18:25:15.444919333 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__UpdateFlags.html 2024-12-27 18:25:15.448919360 +0000
@@ -137,7 +137,7 @@
w_q,
\]" src="form_272.png"/>
- where indicates the index of the quadrature point, its location on the reference cell, and its weight.
+ where indicates the index of the quadrature point, its location on the reference cell, and its weight.
In order to evaluate such an expression in an application code, we have to access three different kinds of objects: a quadrature object that describes locations and weights of quadrature points on the reference cell; a finite element object that describes the gradients of shape functions on the unit cell; and a mapping object that provides the Jacobian as well as its determinant. Dealing with all these objects would be cumbersome and error prone.
On the other hand, these three kinds of objects almost always appear together, and it is in fact very rare for deal.II application codes to do anything with quadrature, finite element, or mapping objects besides using them together. For this reason, deal.II uses the FEValues abstraction combining information on the shape functions, the geometry of the actual mesh cell and a quadrature rule on a reference cell. Upon construction it takes one object of each of the three mentioned categories. Later, it can be "re-initialized" for a concrete grid cell and then provides mapped quadrature points and weights, mapped shape function values and derivatives as well as some properties of the transformation from the reference cell to the actual mesh cell.
/usr/share/doc/packages/dealii/doxygen/deal.II/group__auto__symb__diff.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__auto__symb__diff.html 2024-12-27 18:25:15.476919552 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__auto__symb__diff.html 2024-12-27 18:25:15.480919580 +0000
@@ -116,7 +116,7 @@
A group dedicated to the implementation of functions and classes that relate to automatic and symbolic differentiation.
-
Below we provide a very brief introduction as to what automatic and symbolic differentiation are, what variations of these computational/numerical schemes exist, and how they are integrated within deal.II's framework. The purpose of all of these schemes is to automatically compute the derivative of functions, or approximations of it, in cases where one does not want to compute them by hand. Common examples are situations in the finite element context is where one wants to solve a nonlinear problem that is given by requiring that some residual where is a complicated function that needs to be differentiated to apply Newton's method; and situations where one is given a parameter dependent problem and wants to form derivatives with regards to the parameters , for example to optimize an output functional with regards to , or for a sensitivity analysis with regards to . One should think of as design parameters: say, the width or shape of a wing, the stiffness coefficients of a material chosen to build an object, the power sent to a device, the chemical composition of the gases sent to a burner. In all of these cases, one should think of and as complicated and cumbersome to differentiate – at least when doing it by hand. A relatively simple case of a nonlinear problem that already highlights the tedium of computing derivatives by hand is shown in step-15. However, in reality, one might, for example, think about problems such as chemically reactive flows where the fluid equations have coefficients such as the density and viscosity that depend strongly and nonlinearly on the chemical composition, temperature, and pressure of the fluid at each point; and where the chemical species react with each other based on reaction coefficients that also depend nonlinearly and in complicated ways on the chemical composition, temperature, and pressure. In many cases, the exact formulas for all of these coefficients can take several lines to write out, may include exponentials and (harmonic or geometric) averages of several nonlinear terms, and/or may contain table lookup of and interpolation between data points. Just getting these terms right is difficult enough; computing derivatives of these terms is impractical in most applications and, in reality, impossible to get right. Higher derivatives are even more impossible to do without computer aid. Automatic or symbolic differentiation is a way out of this: One only has to implement the function that computes these coefficients in terms of their inputs only once, and gets the (correct!) derivatives without further coding effort (though at a non-negligible computational cost either at run time, compile time, or both).
+
Below we provide a very brief introduction as to what automatic and symbolic differentiation are, what variations of these computational/numerical schemes exist, and how they are integrated within deal.II's framework. The purpose of all of these schemes is to automatically compute the derivative of functions, or approximations of it, in cases where one does not want to compute them by hand. Common examples are situations in the finite element context is where one wants to solve a nonlinear problem that is given by requiring that some residual where is a complicated function that needs to be differentiated to apply Newton's method; and situations where one is given a parameter dependent problem and wants to form derivatives with regards to the parameters , for example to optimize an output functional with regards to , or for a sensitivity analysis with regards to . One should think of as design parameters: say, the width or shape of a wing, the stiffness coefficients of a material chosen to build an object, the power sent to a device, the chemical composition of the gases sent to a burner. In all of these cases, one should think of and as complicated and cumbersome to differentiate – at least when doing it by hand. A relatively simple case of a nonlinear problem that already highlights the tedium of computing derivatives by hand is shown in step-15. However, in reality, one might, for example, think about problems such as chemically reactive flows where the fluid equations have coefficients such as the density and viscosity that depend strongly and nonlinearly on the chemical composition, temperature, and pressure of the fluid at each point; and where the chemical species react with each other based on reaction coefficients that also depend nonlinearly and in complicated ways on the chemical composition, temperature, and pressure. In many cases, the exact formulas for all of these coefficients can take several lines to write out, may include exponentials and (harmonic or geometric) averages of several nonlinear terms, and/or may contain table lookup of and interpolation between data points. Just getting these terms right is difficult enough; computing derivatives of these terms is impractical in most applications and, in reality, impossible to get right. Higher derivatives are even more impossible to do without computer aid. Automatic or symbolic differentiation is a way out of this: One only has to implement the function that computes these coefficients in terms of their inputs only once, and gets the (correct!) derivatives without further coding effort (though at a non-negligible computational cost either at run time, compile time, or both).
Automatic differentiation
Automatic differentiation (commonly also referred to as algorithmic differentiation), is a numerical method that can be used to "automatically" compute the first, and perhaps higher-order, derivatives of function(s) with respect to one or more input variables. Although this comes at a certain computational cost, the benefits to using such a tool may be significant. When used correctly the derivatives of often complicated functions can be computed to a very high accuracy. Although the exact accuracy achievable by these frameworks largely depends on their underlying mathematical formulation, some implementations compute with a precision on the order of machine accuracy. Note that this is different to classical numerical differentiation (using, for example, a finite difference approximation of a function by evaluating it at different points), which has an accuracy that depends on both the perturbation size as well as the chosen finite-difference scheme; the error of these methods is measurably larger than well-formulated automatic differentiation approaches.
As a point of interest, the optimal Jacobian accumulation, which performs a minimal set of computations, lies somewhere between these two limiting cases. Its computation for a general composite function remains an open problem in graph theory.
-
With the aid of the diagram below (it and some of the listed details courtesy of this Wikipedia article), let us think about the representation of the calculation of the function and its derivatives:
-
Forward mode automatic differentiation
Reverse mode automatic differentiation
Specifically, we will briefly describe what forward and reverse auto-differentiation are. Note that in the diagram, along the edges of the graph in text are the directional derivative of function with respect to the -th variable, represented by the notation . The specific computations used to render the function value and its directional derivatives for this example are tabulated in the source article. For a second illustrative example, we refer the interested reader to this article.
-
Consider first that any composite function , here represented as having two independent variables, can be dissected into a composition of its elementary functions
-Wikipedia article), let us think about the representation of the calculation of the function and its derivatives:
+
Forward mode automatic differentiation
Reverse mode automatic differentiation
Specifically, we will briefly describe what forward and reverse auto-differentiation are. Note that in the diagram, along the edges of the graph in text are the directional derivative of function with respect to the -th variable, represented by the notation . The specific computations used to render the function value and its directional derivatives for this example are tabulated in the source article. For a second illustrative example, we refer the interested reader to this article.
+
Consider first that any composite function , here represented as having two independent variables, can be dissected into a composition of its elementary functions
+
+\]" src="form_10.png"/>
-
As was previously mentioned, if each of the primitive operations is smooth and differentiable, then the chain-rule can be universally employed to compute the total derivative of , namely . What distinguishes the "forward" from the "reverse" mode is how the chain-rule is evaluated, but ultimately both compute the total derivative
- is smooth and differentiable, then the chain-rule can be universally employed to compute the total derivative of , namely . What distinguishes the "forward" from the "reverse" mode is how the chain-rule is evaluated, but ultimately both compute the total derivative
+
+\]" src="form_14.png"/>
-
In forward-mode, the chain-rule is computed naturally from the "inside out". The independent variables are therefore fixed, and each sub-function is computed recursively and its result returned as inputs to the parent function. Encapsulating and fixing the order of operations using parentheses, this means that we compute
- is computed recursively and its result returned as inputs to the parent function. Encapsulating and fixing the order of operations using parentheses, this means that we compute
+
+\]" src="form_16.png"/>
The computational complexity of a forward-sweep is proportional to that of the input function. However, for each directional derivative that is to be computed one sweep of the computational graph is required.
In reverse-mode, the chain-rule is computed somewhat unnaturally from the "outside in". The values of the dependent variables first get computed and fixed, and then the preceding differential operations are evaluated and multiplied in succession with the previous results from left to right. Again, if we encapsulate and fix the order of operations using parentheses, this implies that the reverse calculation is performed by
-
+\]" src="form_17.png"/>
-
The intermediate values are known as adjoints, which must be computed and stored as the computational graph is traversed. However, for each dependent scalar function one sweep of the computational graph renders all directional derivatives at once.
+
The intermediate values are known as adjoints, which must be computed and stored as the computational graph is traversed. However, for each dependent scalar function one sweep of the computational graph renders all directional derivatives at once.
Overall, the efficiency of each mode is determined by the number of independent (input) variables and dependent (output) variables. If the outputs greatly exceed the inputs in number, then forward-mode can be shown to be more efficient than reverse-mode. The converse is true when the number of input variables greatly exceeds that of the output variables. This point may be used to help inform which number type is most suitable for which set of operations are to be performed using automatic differentiation. For example, in many applications for which second derivatives are to be computed it is appropriate to combine both reverse- and forward-modes. The former would then typically be used to calculate the first derivatives, and the latter the second derivatives.
Supported automatic differentiation libraries
@@ -343,7 +343,7 @@
Symbolic expressions and differentiation
Symbolic differentiation is, in terms of its design and usage, quite different to automatic differentiation. Underlying any symbolic library is a computer algebra system (CAS) that implements a language and collection of algorithms to manipulate symbolic (or "string-like") expressions. This is most similar, from a philosophical point of view, to how algebraic operations would be performed by hand.
-
To help better distinguish between symbolic differentiation and numerical methods like automatic differentiation, let's consider a very simple example. Suppose that the function , where and are variables that are independent of one another. By applying the chain-rule, the derivatives of this function are simply and . These are exactly the results that you get from a CAS after defining the symbolic variables x and y, defining the symbolic expression f = pow(2x+1, y) and computing the derivatives diff(f, x) and diff(f, y). At this point there is no assumption of what x and y represent; they may later be interpreted as plain (scalar) numbers, complex numbers, or something else for which the power and natural logarithm functions are well defined. Obviously this means that there is also no assumption about which point to evaluate either the expression or its derivatives. One could readily take the expression for and evaluate it at and then later, with no recomputation of the derivative expression itself, evaluate it at . In fact, the interpretation of any symbolic variable or expression, and the inter-dependencies between variables, may be defined or redefined at any point during their manipulation; this leads to a degree of flexibility in computations that cannot be matched by auto-differentiation. For example, one could perform the permanent substitution and then recompute for several different values of . One could also post-factum express an interdependency between x and y, such as . For such a case, this means that the initially computed derivatives and truly represent partial derivatives rather than total derivatives. Of course, if such an inter-dependency was explicitly defined before the derivatives and are computed, then this could correspond to the total derivative (which is the only result that auto-differentiation is able to achieve for this example).
+
To help better distinguish between symbolic differentiation and numerical methods like automatic differentiation, let's consider a very simple example. Suppose that the function , where and are variables that are independent of one another. By applying the chain-rule, the derivatives of this function are simply and . These are exactly the results that you get from a CAS after defining the symbolic variables x and y, defining the symbolic expression f = pow(2x+1, y) and computing the derivatives diff(f, x) and diff(f, y). At this point there is no assumption of what x and y represent; they may later be interpreted as plain (scalar) numbers, complex numbers, or something else for which the power and natural logarithm functions are well defined. Obviously this means that there is also no assumption about which point to evaluate either the expression or its derivatives. One could readily take the expression for and evaluate it at and then later, with no recomputation of the derivative expression itself, evaluate it at . In fact, the interpretation of any symbolic variable or expression, and the inter-dependencies between variables, may be defined or redefined at any point during their manipulation; this leads to a degree of flexibility in computations that cannot be matched by auto-differentiation. For example, one could perform the permanent substitution and then recompute for several different values of . One could also post-factum express an interdependency between x and y, such as . For such a case, this means that the initially computed derivatives and truly represent partial derivatives rather than total derivatives. Of course, if such an inter-dependency was explicitly defined before the derivatives and are computed, then this could correspond to the total derivative (which is the only result that auto-differentiation is able to achieve for this example).
Due to the sophisticated CAS that forms the foundation of symbolic operations, the types of manipulations are not necessarily restricted to differentiation alone, but rather may span a spectrum of manipulations relevant to discrete differential calculus, topics in pure mathematics, and more. The documentation for the SymPy library gives plenty of examples that highlight what a fully-fledged CAS is capable of. Through the Differentiation::SD::Expression class, and the associated functions in the Differentiation::SD namespace, we provide a wrapper to the high-performance SymEngine symbolic manipulation library that has enriched operator overloading and a consistent interface that makes it easy and "natural" to use. In fact, this class can be used as a "drop-in" replacement for arithmetic types in many situations, transforming the operations from being numeric to symbolic in nature; this is made especially easy when classes are templated on the underlying number type. Being focused on numerical simulation of PDEs, the functionality of the CAS that is exposed within deal.II focuses on symbolic expression creation, manipulation, and differentiation.
The convenience wrappers to SymEngine functionality are primarily focused on manipulations that solely involve dictionary-based (i.e., something reminiscent of "string-based") operations. Although SymEngine performs these operations in an efficient manner, they are still known to be computationally expensive, especially when the operations are performed on large expressions. It should therefore be expected that the performance of the parts of code that perform differentiation, symbolic substitution, etc., may be a limiting factor when using this in production code. deal.II therefore provides an interface to accelerate the evaluation of lengthy symbolic expression through the BatchOptimizer class (itself often leveraging functionality provided by SymEngine). In particular, the BatchOptimizer simultaneously optimizes a collection of symbolic expressions using methods such as common subexpression elimination (CSE), as well as by generating high performance code-paths to evaluate these expressions through the use of a custom-generated std::function or by compiling the expression using the LLVM JIT compiler. The usage of the Differentiation::SD::BatchOptimizer class is exemplified in step-71.
As a final note, it is important to recognize the remaining major deficiencies in deal.II's current implementation of the interface to the supported symbolic library. The level of functionality currently implemented effectively limits the use of symbolic algebra to the traditional use case (i.e. scalar and tensor algebra, as might be useful to define constitutive relations or complex functions for application as boundary conditions or source terms). In fact, step-71 demonstrates how it can be used to implement challenging constitutive models. In the future we will also implement classes to assist in performing assembly operations in the same spirit as that which has been done in the Differentiation::AD namespace.
/usr/share/doc/packages/dealii/doxygen/deal.II/group__constraints.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__constraints.html 2024-12-27 18:25:15.556920102 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__constraints.html 2024-12-27 18:25:15.560920129 +0000
@@ -216,7 +216,7 @@
If you have boundary conditions that set a certain part of the solution's value, for example no normal flux, (as happens in flow problems and is handled by the VectorTools::compute_no_normal_flux_constraints function) or prescribed tangential components, (as happens in electromagnetic problems and is handled by the VectorTools::project_boundary_values_curl_conforming function). For the former case, imagine for example that we are at at vertex where the normal vector has the form and that the -, - and -components of the flow field at this vertex are associated with degrees of freedom 12, 28, and 40. Then the no-normal-flux condition means that we need to have the condition . The prescribed tangential component leads to similar constraints though there is often something on the right hand side.
+ (1,2,3)^T$" src="form_43.png"/> and that the -, - and -components of the flow field at this vertex are associated with degrees of freedom 12, 28, and 40. Then the no-normal-flux condition means that we need to have the condition . The prescribed tangential component leads to similar constraints though there is often something on the right hand side.
If you have hanging node constraints, for example in a mesh like this:
@@ -309,7 +309,7 @@
\]" src="form_70.png"/>
instead (see, for example, [Shephard1984]).
-
Here, is a given (unconstrained) system matrix for which we only assume that we can apply it to a vector but can not necessarily access individual matrix entries. is the corresponding right hand side of a system of linear equations . The matrix describes the homogeneous part of the linear constraints stored in an AffineConstraints object and the vector is the vector of corresponding inhomogeneities. More precisely, the AffineConstraints::distribute() operation applied on a vector is the operation
+
Here, is a given (unconstrained) system matrix for which we only assume that we can apply it to a vector but can not necessarily access individual matrix entries. is the corresponding right hand side of a system of linear equations . The matrix describes the homogeneous part of the linear constraints stored in an AffineConstraints object and the vector is the vector of corresponding inhomogeneities. More precisely, the AffineConstraints::distribute() operation applied on a vector is the operation
@@ -376,7 +376,7 @@
Compute which entries of a matrix built on the given dof_handler may possibly be nonzero, and create a sparsity pattern object that represents these nonzero locations.
-
This function computes the possible positions of non-zero entries in the global system matrix by simulating which entries one would write to during the actual assembly of a matrix. For this, the function assumes that each finite element basis function is non-zero on a cell only if its degree of freedom is associated with the interior, a face, an edge or a vertex of this cell. As a result, a matrix entry that is computed from two basis functions and with (global) indices and (for example, using a bilinear form ) can be non-zero only if these shape functions correspond to degrees of freedom that are defined on at least one common cell. Therefore, this function just loops over all cells, figures out the global indices of all degrees of freedom, and presumes that all matrix entries that couple any of these indices will result in a nonzero matrix entry. These will then be added to the sparsity pattern. As this process of generating the sparsity pattern does not take into account the equation to be solved later on, the resulting sparsity pattern is symmetric.
+
This function computes the possible positions of non-zero entries in the global system matrix by simulating which entries one would write to during the actual assembly of a matrix. For this, the function assumes that each finite element basis function is non-zero on a cell only if its degree of freedom is associated with the interior, a face, an edge or a vertex of this cell. As a result, a matrix entry that is computed from two basis functions and with (global) indices and (for example, using a bilinear form ) can be non-zero only if these shape functions correspond to degrees of freedom that are defined on at least one common cell. Therefore, this function just loops over all cells, figures out the global indices of all degrees of freedom, and presumes that all matrix entries that couple any of these indices will result in a nonzero matrix entry. These will then be added to the sparsity pattern. As this process of generating the sparsity pattern does not take into account the equation to be solved later on, the resulting sparsity pattern is symmetric.
This algorithm makes no distinction between shape functions on each cell, i.e., it simply couples all degrees of freedom on a cell with all other degrees of freedom on a cell. This is often the case, and always a safe assumption. However, if you know something about the structure of your operator and that it does not couple certain shape functions with certain test functions, then you can get a sparser sparsity pattern by calling a variant of the current function described below that allows to specify which vector components couple with which other vector components.
The method described above lives on the assumption that coupling between degrees of freedom only happens if shape functions overlap on at least one cell. This is the case with most usual finite element formulations involving conforming elements. However, for formulations such as the Discontinuous Galerkin finite element method, the bilinear form contains terms on interfaces between cells that couple shape functions that live on one cell with shape functions that live on a neighboring cell. The current function would not see these couplings, and would consequently not allocate entries in the sparsity pattern. You would then get into trouble during matrix assembly because you try to write into matrix entries for which no space has been allocated in the sparsity pattern. This can be avoided by calling the DoFTools::make_flux_sparsity_pattern() function instead, which takes into account coupling between degrees of freedom on neighboring cells.
There are other situations where bilinear forms contain non-local terms, for example in treating integral equations. These require different methods for building the sparsity patterns that depend on the exact formulation of the problem. You will have to do this yourself then.
@@ -446,7 +446,7 @@
-\Delta \mathbf u + \nabla p &= 0,\\ \text{div}\ u &= 0
\end{align*}" src="form_1013.png"/>
-
in two space dimensions, using stable Q2/Q1 mixed elements (using the FESystem class), then you don't want all degrees of freedom to couple in each equation. More specifically, in the first equation, only and appear; in the second equation, only and appear; and in the third equation, only and appear. (Note that this discussion only talks about vector components of the solution variable and the different equation, and has nothing to do with degrees of freedom, or in fact with any kind of discretization.) We can describe this by the following pattern of "couplings":
+
in two space dimensions, using stable Q2/Q1 mixed elements (using the FESystem class), then you don't want all degrees of freedom to couple in each equation. More specifically, in the first equation, only and appear; in the second equation, only and appear; and in the third equation, only and appear. (Note that this discussion only talks about vector components of the solution variable and the different equation, and has nothing to do with degrees of freedom, or in fact with any kind of discretization.) We can describe this by the following pattern of "couplings":
This function is an updated version of the project_boundary_values_curl_conforming function. The intention is to fix a problem when using the previous function in conjunction with non-rectangular geometries (i.e. elements with non-rectangular faces). The L2-projection method used has been taken from the paper "Electromagnetic
scattering simulation using an H (curl) conforming hp-finite element
method in three dimensions" by PD Ledger, K Morgan and O Hassan ( Int. J. Num. Meth. Fluids, Volume 53, Issue 8, pages 1267-1296).
-
This function will compute constraints that correspond to Dirichlet boundary conditions of the form i.e. the tangential components of and shall coincide.
+
This function will compute constraints that correspond to Dirichlet boundary conditions of the form i.e. the tangential components of and shall coincide.
Computing constraints
To compute the constraints we use a projection method based upon the paper mentioned above. In 2d this is done in a single stage for the edge-based shape functions, regardless of the order of the finite element. In 3d this is done in two stages, edges first and then faces.
-
For each cell, each edge, , is projected by solving the linear system where is the vector of constraints on degrees of freedom on the edge and
-
-
-
with the shape function and the tangent vector.
-
Once all edge constraints, , have been computed, we may compute the face constraints in a similar fashion, taking into account the residuals from the edges.
-
For each face on the cell, , we solve the linear system where is the vector of constraints on degrees of freedom on the face and
-
-
-
and , the edge residual.
-
The resulting constraints are then given in the solutions and .
+
For each cell, each edge, , is projected by solving the linear system where is the vector of constraints on degrees of freedom on the edge and
+
+
+
with the shape function and the tangent vector.
+
Once all edge constraints, , have been computed, we may compute the face constraints in a similar fashion, taking into account the residuals from the edges.
+
For each face on the cell, , we solve the linear system where is the vector of constraints on degrees of freedom on the face and
+
+
+
and , the edge residual.
+
The resulting constraints are then given in the solutions and .
If the AffineConstraintsconstraints contained values or other constraints before, the new ones are added or the old ones overwritten, if a node of the boundary part to be used was already in the list of constraints. This is handled by using inhomogeneous constraints. Please note that when combining adaptive meshes and this kind of constraints, the Dirichlet conditions should be set first, and then completed by hanging node constraints, in order to make sure that the discretization remains consistent. See the discussion on conflicting constraints in the topic on Constraints on degrees of freedom.
Arguments to this function
This function is explicitly for use with FE_Nedelec elements, or with FESystem elements which contain FE_Nedelec elements. It will throw an exception if called with any other finite element. The user must ensure that FESystem elements are correctly setup when using this function as this check not possible in this case.
-
The second argument of this function denotes the first vector component of the finite element which corresponds to the vector function that you wish to constrain. For example, if we are solving Maxwell's equations in 3d and have components and we want the boundary conditions , then first_vector_component would be 3. The boundary_function must return 6 components in this example, with the first 3 corresponding to and the second 3 corresponding to . Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e. -, -, and finally -component.
+
The second argument of this function denotes the first vector component of the finite element which corresponds to the vector function that you wish to constrain. For example, if we are solving Maxwell's equations in 3d and have components and we want the boundary conditions , then first_vector_component would be 3. The boundary_function must return 6 components in this example, with the first 3 corresponding to and the second 3 corresponding to . Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e. -, -, and finally -component.
The parameter boundary_component corresponds to the number boundary_id of the face. numbers::internal_face_boundary_id is an illegal value, since it is reserved for interior faces.
-
The last argument is denoted to compute the normal vector at the boundary points.
+
The last argument is denoted to compute the normal vector at the boundary points.
Compute constraints that correspond to boundary conditions of the form , i.e. the normal components of the solution and a given shall coincide. The function is given by boundary_function and the resulting constraints are added to constraints for faces with boundary indicator boundary_component.
+
Compute constraints that correspond to boundary conditions of the form , i.e. the normal components of the solution and a given shall coincide. The function is given by boundary_function and the resulting constraints are added to constraints for faces with boundary indicator boundary_component.
This function is explicitly written to use with the FE_RaviartThomas elements. Thus it throws an exception, if it is called with other finite elements.
If the AffineConstraints object constraints contained values or other constraints before, the new ones are added or the old ones overwritten, if a node of the boundary part to be used was already in the list of constraints. This is handled by using inhomogeneous constraints. Please note that when combining adaptive meshes and this kind of constraints, the Dirichlet conditions should be set first, and then completed by hanging node constraints, in order to make sure that the discretization remains consistent. See the discussion on conflicting constraints in the topic on Constraints on degrees of freedom.
-
The argument first_vector_component denotes the first vector component in the finite element that corresponds to the vector function that you want to constrain. Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e., -, -, and finally -component.
-
The parameter boundary_component corresponds to the boundary_id of the faces where the boundary conditions are applied. numbers::internal_face_boundary_id is an illegal value, since it is reserved for interior faces. The mapping is used to compute the normal vector at the boundary points.
+
The argument first_vector_component denotes the first vector component in the finite element that corresponds to the vector function that you want to constrain. Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e., -, -, and finally -component.
+
The parameter boundary_component corresponds to the boundary_id of the faces where the boundary conditions are applied. numbers::internal_face_boundary_id is an illegal value, since it is reserved for interior faces. The mapping is used to compute the normal vector at the boundary points.
Computing constraints
To compute the constraints we use interpolation operator proposed in Brezzi, Fortin (Mixed and Hybrid Finite Element Methods, Springer, 1991) on every face located at the boundary.
This function computes the constraints that correspond to boundary conditions of the form , i.e., normal flux constraints where is a vector-valued solution variable and is a prescribed vector field whose normal component we want to be equal to the normal component of the solution. These conditions have exactly the form handled by the AffineConstraints class, in that they relate a linear combination of boundary degrees of freedom to a corresponding value (the inhomogeneity of the constraint). Consequently, the current function creates a list of constraints that are written into an AffineConstraints container. This object may already have some content, for example from hanging node constraints, that remains untouched. These constraints have to be applied to the linear system like any other such constraints, i.e., you have to condense the linear system with the constraints before solving, and you have to distribute the solution vector afterwards.
-
This function treats a more general case than VectorTools::compute_no_normal_flux_constraints() (which can only handle the case where , and is used in step-31 and step-32). However, because everything that would apply to that function also applies as a special case to the current function, the following discussion is relevant to both.
+
This function computes the constraints that correspond to boundary conditions of the form , i.e., normal flux constraints where is a vector-valued solution variable and is a prescribed vector field whose normal component we want to be equal to the normal component of the solution. These conditions have exactly the form handled by the AffineConstraints class, in that they relate a linear combination of boundary degrees of freedom to a corresponding value (the inhomogeneity of the constraint). Consequently, the current function creates a list of constraints that are written into an AffineConstraints container. This object may already have some content, for example from hanging node constraints, that remains untouched. These constraints have to be applied to the linear system like any other such constraints, i.e., you have to condense the linear system with the constraints before solving, and you have to distribute the solution vector afterwards.
+
This function treats a more general case than VectorTools::compute_no_normal_flux_constraints() (which can only handle the case where , and is used in step-31 and step-32). However, because everything that would apply to that function also applies as a special case to the current function, the following discussion is relevant to both.
Note
This function doesn't make much sense in 1d, so it throws an exception if dim equals one.
Arguments to this function
-
The second argument of this function denotes the first vector component in the finite element that corresponds to the vector function that you want to constrain. For example, if we were solving a Stokes equation in 2d and the finite element had components , then first_vector_component needs to be zero if you intend to constraint the vector . On the other hand, if we solved the Maxwell equations in 3d and the finite element has components and we want the boundary condition , then first_vector_component would be 3. Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e. -, -, and finally -component. The function assumes, but can't check, that the vector components in the range [first_vector_component,first_vector_component+dim) come from the same base finite element. For example, in the Stokes example above, it would not make sense to use a FESystem<dim>(FE_Q<dim>(2), 1, FE_Q<dim>(1), dim) (note that the first velocity vector component is a element, whereas all the other ones are elements) as there would be points on the boundary where the -velocity is defined but no corresponding - or -velocities.
+
The second argument of this function denotes the first vector component in the finite element that corresponds to the vector function that you want to constrain. For example, if we were solving a Stokes equation in 2d and the finite element had components , then first_vector_component needs to be zero if you intend to constraint the vector . On the other hand, if we solved the Maxwell equations in 3d and the finite element has components and we want the boundary condition , then first_vector_component would be 3. Vectors are implicitly assumed to have exactly dim components that are ordered in the same way as we usually order the coordinate directions, i.e. -, -, and finally -component. The function assumes, but can't check, that the vector components in the range [first_vector_component,first_vector_component+dim) come from the same base finite element. For example, in the Stokes example above, it would not make sense to use a FESystem<dim>(FE_Q<dim>(2), 1, FE_Q<dim>(1), dim) (note that the first velocity vector component is a element, whereas all the other ones are elements) as there would be points on the boundary where the -velocity is defined but no corresponding - or -velocities.
The third argument denotes the set of boundary indicators on which the boundary condition is to be enforced. Note that, as explained below, this is one of the few functions where it makes a difference where we call the function multiple times with only one boundary indicator, or whether we call the function once with the whole set of boundary indicators at once.
-
Argument four (function_map) describes the boundary function for each boundary id. The function function_map[id] is used on boundary with id id taken from the set boundary_ids. Each function in function_map is expected to have dim components, which are used independent of first_vector_component.
-
The mapping argument is used to compute the location of points on the boundary at which the function needs to request the normal vector from the Manifold description if use_manifold_for_normal is set. If this parameter is not set, the mapping is used for computing the normal. This is useful, e.g., in the case that the mapping describes a deformation (e.g., MappingQCache, MappingQEulerian, MappingFEField).
+
Argument four (function_map) describes the boundary function for each boundary id. The function function_map[id] is used on boundary with id id taken from the set boundary_ids. Each function in function_map is expected to have dim components, which are used independent of first_vector_component.
+
The mapping argument is used to compute the location of points on the boundary at which the function needs to request the normal vector from the Manifold description if use_manifold_for_normal is set. If this parameter is not set, the mapping is used for computing the normal. This is useful, e.g., in the case that the mapping describes a deformation (e.g., MappingQCache, MappingQEulerian, MappingFEField).
Note
When combining adaptively refined meshes with hanging node constraints and boundary conditions like from the current function within one AffineConstraints object, the hanging node constraints should always be set first, and then the boundary conditions since boundary conditions are not set in the second operation on degrees of freedom that are already constrained. This makes sure that the discretization remains conforming as is needed. See the discussion on conflicting constraints in the topic on Constraints on degrees of freedom.
Computing constraints in 2d
Computing these constraints requires some smarts. The main question revolves around the question what the normal vector is. Consider the following situation:
@@ -1376,23 +1376,23 @@
-
Here, we have two cells that use a bilinear mapping (i.e., MappingQ(1)). Consequently, for each of the cells, the normal vector is perpendicular to the straight edge. If the two edges at the top and right are meant to approximate a curved boundary (as indicated by the dashed line), then neither of the two computed normal vectors are equal to the exact normal vector (though they approximate it as the mesh is refined further). What is worse, if we constrain at the common vertex with the normal vector from both cells, then we constrain the vector with respect to two linearly independent vectors; consequently, the constraint would be at this point (i.e. all components of the vector), which is not what we wanted.
-
To deal with this situation, the algorithm works in the following way: at each point where we want to constrain , we first collect all normal vectors that adjacent cells might compute at this point. We then do not constrain for each of these normal vectors but only for the average of the normal vectors. In the example above, we therefore record only a single constraint , where is the average of the two indicated normal vectors.
+
Here, we have two cells that use a bilinear mapping (i.e., MappingQ(1)). Consequently, for each of the cells, the normal vector is perpendicular to the straight edge. If the two edges at the top and right are meant to approximate a curved boundary (as indicated by the dashed line), then neither of the two computed normal vectors are equal to the exact normal vector (though they approximate it as the mesh is refined further). What is worse, if we constrain at the common vertex with the normal vector from both cells, then we constrain the vector with respect to two linearly independent vectors; consequently, the constraint would be at this point (i.e. all components of the vector), which is not what we wanted.
+
To deal with this situation, the algorithm works in the following way: at each point where we want to constrain , we first collect all normal vectors that adjacent cells might compute at this point. We then do not constrain for each of these normal vectors but only for the average of the normal vectors. In the example above, we therefore record only a single constraint , where is the average of the two indicated normal vectors.
Unfortunately, this is not quite enough. Consider the situation here:
-
If again the top and right edges approximate a curved boundary, and the left boundary a separate boundary (for example straight) so that the exact boundary has indeed a corner at the top left vertex, then the above construction would not work: here, we indeed want the constraint that at this point (because the normal velocities with respect to both the left normal as well as the top normal vector should be zero), not that the velocity in the direction of the average normal vector is zero.
+
If again the top and right edges approximate a curved boundary, and the left boundary a separate boundary (for example straight) so that the exact boundary has indeed a corner at the top left vertex, then the above construction would not work: here, we indeed want the constraint that at this point (because the normal velocities with respect to both the left normal as well as the top normal vector should be zero), not that the velocity in the direction of the average normal vector is zero.
Consequently, we use the following heuristic to determine whether all normal vectors computed at one point are to be averaged: if two normal vectors for the same point are computed on different cells, then they are to be averaged. This covers the first example above. If they are computed from the same cell, then the fact that they are different is considered indication that they come from different parts of the boundary that might be joined by a real corner, and must not be averaged.
There is one problem with this scheme. If, for example, the same domain we have considered above, is discretized with the following mesh, then we get into trouble:
-
Here, the algorithm assumes that the boundary does not have a corner at the point where faces and join because at that point there are two different normal vectors computed from different cells. If you intend for there to be a corner of the exact boundary at this point, the only way to deal with this is to assign the two parts of the boundary different boundary indicators and call this function twice, once for each boundary indicators; doing so will yield only one normal vector at this point per invocation (because we consider only one boundary part at a time), with the result that the normal vectors will not be averaged. This situation also needs to be taken into account when using this function around reentrant corners on Cartesian meshes. If normal-flux boundary conditions are to be enforced on non-Cartesian meshes around reentrant corners, one may even get cycles in the constraints as one will in general constrain different components from the two sides. In that case, set a no-slip constraint on the reentrant vertex first.
+
Here, the algorithm assumes that the boundary does not have a corner at the point where faces and join because at that point there are two different normal vectors computed from different cells. If you intend for there to be a corner of the exact boundary at this point, the only way to deal with this is to assign the two parts of the boundary different boundary indicators and call this function twice, once for each boundary indicators; doing so will yield only one normal vector at this point per invocation (because we consider only one boundary part at a time), with the result that the normal vectors will not be averaged. This situation also needs to be taken into account when using this function around reentrant corners on Cartesian meshes. If normal-flux boundary conditions are to be enforced on non-Cartesian meshes around reentrant corners, one may even get cycles in the constraints as one will in general constrain different components from the two sides. In that case, set a no-slip constraint on the reentrant vertex first.
Computing constraints in 3d
The situation is more complicated in 3d. Consider the following case where we want to compute the constraints at the marked vertex:
This function does the same as the compute_nonzero_normal_flux_constraints() function (see there for more information), but for the simpler case of homogeneous normal-flux constraints, i.e., for imposing the condition . This function is used in step-31 and step-32.
+
This function does the same as the compute_nonzero_normal_flux_constraints() function (see there for more information), but for the simpler case of homogeneous normal-flux constraints, i.e., for imposing the condition . This function is used in step-31 and step-32.
Compute the constraints that correspond to boundary conditions of the form , i.e., tangential flow constraints where is a vector-valued solution variable and is prescribed vector field whose tangential component(s) we want to be equal to the tangential component(s) of the solution. This function constrains exactly those dim-1 vector-valued components that are left unconstrained by VectorTools::compute_no_normal_flux_constraints(), and leaves the one component unconstrained that is constrained by that function.
+
Compute the constraints that correspond to boundary conditions of the form , i.e., tangential flow constraints where is a vector-valued solution variable and is prescribed vector field whose tangential component(s) we want to be equal to the tangential component(s) of the solution. This function constrains exactly those dim-1 vector-valued components that are left unconstrained by VectorTools::compute_no_normal_flux_constraints(), and leaves the one component unconstrained that is constrained by that function.
Further reading
A description of some of the techniques used in this function, along with a discussion of difficulties encountered with this kind of boundary conditions can be found in [Engelman1982] .
-
/usr/share/doc/packages/dealii/doxygen/deal.II/group__hpcollection.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__hpcollection.html 2024-12-27 18:25:15.592920349 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__hpcollection.html 2024-12-27 18:25:15.596920376 +0000
@@ -130,7 +130,7 @@
* fe_collection.push_back (FE_Q<dim>(degree));
*
This way, one can add elements of polynomial degree 1 through 4 to the collection. It is not necessary to retain the added object: the collection makes a copy of it, it does not only store a pointer to the given finite element object. This same observation also holds for the other collection classes.
It is customary that within an hp-finite element program, one keeps collections of finite elements and quadrature formulas with the same number of elements, each element of the one collection matching the element in the other. This is not necessary, but it often makes coding a lot simpler. If a collection of mappings is used, the same holds for hp::MappingCollection objects as well.
-
Whenever p-adaptivity is considered in an hp-finite element program, a hierarchy of finite elements needs to be established to determine succeeding finite elements for refinement and preceding ones for coarsening. Typically, this hierarchy considers how finite element spaces are nested: for example, a element describes a sub-space of a element, and so doing refinement usually means using a larger (more accurate) finite element space. In other words, the hierarchy of finite elements is built by considering whether some elements of the collection are sub- or super-spaces of others.
+
Whenever p-adaptivity is considered in an hp-finite element program, a hierarchy of finite elements needs to be established to determine succeeding finite elements for refinement and preceding ones for coarsening. Typically, this hierarchy considers how finite element spaces are nested: for example, a element describes a sub-space of a element, and so doing refinement usually means using a larger (more accurate) finite element space. In other words, the hierarchy of finite elements is built by considering whether some elements of the collection are sub- or super-spaces of others.
By default, we assume that finite elements are stored in an ascending order based on their polynomial degree. If the order of elements differs, a corresponding hierarchy needs to be supplied to the collection via the hp::FECollection::set_hierarchy() member function.
/usr/share/doc/packages/dealii/doxygen/deal.II/group__mapping.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__mapping.html 2024-12-27 18:25:15.616920514 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__mapping.html 2024-12-27 18:25:15.620920541 +0000
@@ -179,7 +179,7 @@
-
A class that implements a polynomial mapping of degree on all cells. This class is completely equivalent to the MappingQ class and there for backward compatibility.
+
A class that implements a polynomial mapping of degree on all cells. This class is completely equivalent to the MappingQ class and there for backward compatibility.
/usr/share/doc/packages/dealii/doxygen/deal.II/group__reordering.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__reordering.html 2024-12-27 18:25:15.660920816 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__reordering.html 2024-12-27 18:25:15.660920816 +0000
@@ -260,7 +260,7 @@
From the examples above, it is obvious that if we encounter a cell that cannot be added to the cells which have already been entered, we can not usually point to a cell that is the culprit and that must be entered in a different orientation. Furthermore, even if we knew which cell, there might be large number of cells that would then cease to fit into the grid and which we would have to find a different orientation as well (in the second example above, if we rotated cell 1, then we would have to rotate the cells 1 through N-1 as well).
A brute force approach to this problem is the following: if cell N can't be added, then try to rotate cell N-1. If we can't rotate cell N-1 any more, then try to rotate cell N-2 and try to add cell N with all orientations of cell N-1. And so on. Algorithmically, we can visualize this by a tree structure, where node N has as many children as there are possible orientations of node N+1 (in two space dimensions, there are four orientations in which each cell can be constructed from its four vertices; for example, if the vertex indices are {0 1 3 2}, then the four possibilities would be {0, 1, 3, 2}, {1, 3, 2, 0}, {3, 2, 0, 1}, and {2, 0, 1, 3}. When adding one cell after the other, we traverse this tree in a depth-first (pre-order) fashion. When we encounter that one path from the root (cell 0) to a leaf (the last cell) is not allowed (i.e. that the orientations of the cells which are encoded in the path through the tree does not lead to a valid triangulation), we have to track back and try another path through the tree.
In practice, of course, we do not follow each path to a final node and then find out whether a path leads to a valid triangulation, but rather use an inductive argument: if for all previously added cells the triangulation is a valid one, then we can find out whether a path through the tree can yield a valid triangulation by checking whether entering the present cell would introduce any faces that have a nonunique direction; if that is so, then we can stop following all paths below this point and track back immediately.
-
Nevertheless, it is already obvious that the tree has leaves in two space dimensions, since each of the cells can be added in four orientations. Most of these nodes can be discarded rapidly, since firstly the orientation of the first cell is irrelevant, and secondly if we add one cell that has a neighbor that has already been added, then there are already only two possible orientations left, so the total number of checks we have to make until we find a valid way is significantly smaller than . However, the algorithm is still exponential in time and linear in memory (we only have to store the information for the present path in form of a stack of orientations of cells that have already been added).
+
Nevertheless, it is already obvious that the tree has leaves in two space dimensions, since each of the cells can be added in four orientations. Most of these nodes can be discarded rapidly, since firstly the orientation of the first cell is irrelevant, and secondly if we add one cell that has a neighbor that has already been added, then there are already only two possible orientations left, so the total number of checks we have to make until we find a valid way is significantly smaller than . However, the algorithm is still exponential in time and linear in memory (we only have to store the information for the present path in form of a stack of orientations of cells that have already been added).
In fact, the two examples above show that the exponential estimate is not a pessimistic one: we indeed have to track back to one of the very first cells there to find a way to add all cells in a consistent fashion.
This discouraging situation is greatly improved by the fact that we have an alternative algorithm for 2d that is always linear in runtime (discovered and implemented by Michael Anderson of TICAM, University of Texas, in 2003), and that for 3d we can find an algorithm that in practice is usually only roughly linear in time and memory. We will describe these algorithms in the following. A full description and theoretical analysis is given in [AABB17] .
The 2d linear complexity algorithm
/usr/share/doc/packages/dealii/doxygen/deal.II/group__threads.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__threads.html 2024-12-27 18:25:15.700921091 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__threads.html 2024-12-27 18:25:15.708921146 +0000
@@ -310,7 +310,7 @@
In this example, we used a lambda expression to construct, on the fly, a function object that takes two arguments and returns the sum of the two. This is exactly what we needed when we want to add the individual elements of vectors and and write the sum of the two into the elements of . The function object that we get here is completely known to the compiler and when it expands the loop that results from parallel::transform will be as if we had written the loop in its obvious form:
InputIterator1 in_1 = x.begin();
+
In this example, we used a lambda expression to construct, on the fly, a function object that takes two arguments and returns the sum of the two. This is exactly what we needed when we want to add the individual elements of vectors and and write the sum of the two into the elements of . The function object that we get here is completely known to the compiler and when it expands the loop that results from parallel::transform will be as if we had written the loop in its obvious form:
Here, we call the vmult_on_subrange function on sub-ranges of at least 200 elements each, so that the initial setup cost can amortize.
-
A related operation is when the loops over elements each produce a result that must then be accumulated (other reduction operations than addition of numbers would work as well). An example is to form the matrix norm (it really is only a norm if is positive definite, but let's assume for a moment that it is). A sequential implementation would look like this for sparse matrices:
A related operation is when the loops over elements each produce a result that must then be accumulated (other reduction operations than addition of numbers would work as well). An example is to form the matrix norm (it really is only a norm if is positive definite, but let's assume for a moment that it is). A sequential implementation would look like this for sparse matrices:
The last issue that is worth addressing is that the way we wrote the MyClass::assemble_on_one_cell function above, we create and destroy an FEValues object every time the function is called, i.e. once for each cell in the triangulation. That's an immensely expensive operation because the FEValues class tries to do a lot of work in its constructor in an attempt to reduce the number of operations we have to do on each cell (i.e. it increases the constant in the effort to initialize such an object in order to reduce the constant in the operations to call FEValues::reinit on the cells of a triangulation). Creating and destroying an FEValues object on each cell invalidates this effort.
+
The last issue that is worth addressing is that the way we wrote the MyClass::assemble_on_one_cell function above, we create and destroy an FEValues object every time the function is called, i.e. once for each cell in the triangulation. That's an immensely expensive operation because the FEValues class tries to do a lot of work in its constructor in an attempt to reduce the number of operations we have to do on each cell (i.e. it increases the constant in the effort to initialize such an object in order to reduce the constant in the operations to call FEValues::reinit on the cells of a triangulation). Creating and destroying an FEValues object on each cell invalidates this effort.
The way to avoid this is to put the FEValues object into a second structure that will hold scratch data, and initialize it in the constructor:
/usr/share/doc/packages/dealii/doxygen/deal.II/group__vector__valued.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/group__vector__valued.html 2024-12-27 18:25:15.748921420 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/group__vector__valued.html 2024-12-27 18:25:15.756921475 +0000
@@ -294,8 +294,8 @@
\right)
\end{eqnarray*}" src="form_302.png"/>
-
indeed has four components. We note that we could change the ordering of the solution components and inside if we also change columns of the matrix operator.
-
Next, we need to think about test functions . We want to multiply both sides of the equation with them, then integrate over . The result should be a scalar equality. We can achieve this by choosing also vector valued as
+
indeed has four components. We note that we could change the ordering of the solution components and inside if we also change columns of the matrix operator.
+
Next, we need to think about test functions . We want to multiply both sides of the equation with them, then integrate over . The result should be a scalar equality. We can achieve this by choosing also vector valued as
-
These views can then be asked for information about these individual components. For example, when you write fe_values[pressure].value(i,q) you get the value of the pressure component of the th shape function at the th quadrature point. Because the extractor pressure represents a scalar component, the results of the operator fe_values[pressure].value(i,q) is a scalar number. On the other hand, the call fe_values[velocities].value(i,q) would produce the value of a whole set of dim components, which would be of type Tensor<1,dim>.
+
These views can then be asked for information about these individual components. For example, when you write fe_values[pressure].value(i,q) you get the value of the pressure component of the th shape function at the th quadrature point. Because the extractor pressure represents a scalar component, the results of the operator fe_values[pressure].value(i,q) is a scalar number. On the other hand, the call fe_values[velocities].value(i,q) would produce the value of a whole set of dim components, which would be of type Tensor<1,dim>.
So if, again, this is not the code we use in step-8, what do we do there? The answer rests on the finite element we use. In step-8, we use the following element:
In other words, the finite element we use consists of dim copies of the same scalar element. This is what we call a primitive element: an element that may be vector-valued but where each shape function has exactly one non-zero component. In other words: if the -component of a displacement shape function is nonzero, then the - and -components must be zero and similarly for the other components. What this means is that also derived quantities based on shape functions inherit this sparsity property. For example: the divergence primitive element: an element that may be vector-valued but where each shape function has exactly one non-zero component. In other words: if the -component of a displacement shape function is nonzero, then the - and -components must be zero and similarly for the other components. What this means is that also derived quantities based on shape functions inherit this sparsity property. For example: the divergence of a vector-valued shape function is, in the present case, either , , or , because exactly one of the is nonzero. Knowing this means that we can save a number of computations that, if we were to do them, would only yield zeros to add up.
In a similar vein, if only one component of a shape function is nonzero, then only one row of its gradient is nonzero. What this means for terms like , where the scalar product between two tensors is defined as , is that the term is only nonzero if both tensors have their nonzero entries in the same row, which means that the two shape functions have to have their single nonzero component in the same location.
-
If we use this sort of knowledge, then we can in a first step avoid computing gradient tensors if we can determine up front that their scalar product will be nonzero, in a second step avoid building the entire tensors and only get its nonzero components, and in a final step simplify the scalar product by only considering that index for the one nonzero row, rather than multiplying and adding up zeros.
+
If we use this sort of knowledge, then we can in a first step avoid computing gradient tensors if we can determine up front that their scalar product will be nonzero, in a second step avoid building the entire tensors and only get its nonzero components, and in a final step simplify the scalar product by only considering that index for the one nonzero row, rather than multiplying and adding up zeros.
The vehicle for all this is the ability to determine which vector component is going to be nonzero. This information is provided by the FiniteElement::system_to_component_index function. What can be done with it, using the example above, is explained in detail in step-8.
Block solvers
Using techniques as shown above, it isn't particularly complicated to assemble the linear system, i.e. matrix and right hand side, for a vector-valued problem. However, then it also has to be solved. This is more complicated. Naively, one could just consider the matrix as a whole. For most problems, this matrix is not going to be definite (except for special cases like the elasticity equations covered in step-8 and step-17). It will, often, also not be symmetric. This rather general class of matrices presents problems for iterative solvers: the lack of structural properties prevents the use of most efficient methods and preconditioners. While it can be done, the solution process will therefore most often be slower than necessary.
where represents the mass matrix that results from discretizing the identity operator and the equivalent of the gradient operator.
+
where represents the mass matrix that results from discretizing the identity operator and the equivalent of the gradient operator.
By default, this is not what happens, however. Rather, deal.II assigns numbers to degrees of freedom in a rather random manner. Consequently, if you form a vector out of the values of degrees of freedom will not be neatly ordered in a vector like
-
This has the advantage that the matrices and that we have to solve with are both symmetric and positive definite, as opposed to the large whole matrix we had before.
-
How a solver like this is implemented is explained in more detail in step-20, step-31, and a few other tutorial programs. What we would like to point out here is that we now need a way to extract certain parts of a matrix or vector: if we are to multiply, say, the part of the solution vector by the part of the global matrix, then we need to have a way to access these parts of the whole.
+
This has the advantage that the matrices and that we have to solve with are both symmetric and positive definite, as opposed to the large whole matrix we had before.
+
How a solver like this is implemented is explained in more detail in step-20, step-31, and a few other tutorial programs. What we would like to point out here is that we now need a way to extract certain parts of a matrix or vector: if we are to multiply, say, the part of the solution vector by the part of the global matrix, then we need to have a way to access these parts of the whole.
This is where the BlockVector, BlockSparseMatrix, and similar classes come in. For all practical purposes, then can be used as regular vectors or sparse matrices, i.e. they offer element access, provide the usual vector operations and implement, for example, matrix-vector multiplications. In other words, assembling matrices and right hand sides works in exactly the same way as for the non-block versions. That said, internally they store the elements of vectors and matrices in "blocks"; for example, instead of using one large array, the BlockVector class stores it as a set of arrays each of which we call a block. The advantage is that, while the whole thing can be used as a vector, one can also access an individual block which then, again, is a vector with all the vector operations.
To show how to do this, let us consider the second equation to be solved above. This can be achieved using the following sequence similar to what we have in step-20:
What's happening here is that we allocate a temporary vector with as many elements as the first block of the solution vector, i.e. the velocity component , has. We then set this temporary vector equal to the block of the matrix, i.e. , times component 1 of the solution which is the previously computed pressure . The result is multiplied by , and component 0 of the right hand side, is added to it. The temporary vector now contains . The rest of the code snippet simply solves a linear system with as right hand side and the block of the global matrix, i.e. . Using block vectors and matrices in this way therefore allows us to quite easily write rather complicated solvers making use of the block structure of a linear system.
+
What's happening here is that we allocate a temporary vector with as many elements as the first block of the solution vector, i.e. the velocity component , has. We then set this temporary vector equal to the block of the matrix, i.e. , times component 1 of the solution which is the previously computed pressure . The result is multiplied by , and component 0 of the right hand side, is added to it. The temporary vector now contains . The rest of the code snippet simply solves a linear system with as right hand side and the block of the global matrix, i.e. . Using block vectors and matrices in this way therefore allows us to quite easily write rather complicated solvers making use of the block structure of a linear system.
Extracting data from solutions
Once one has computed a solution, it is often necessary to evaluate it at quadrature points, for example to evaluate nonlinear residuals for the next Newton iteration, to evaluate the finite element residual for error estimators, or to compute the right hand side for the next time step in a time dependent problem.
The way this is done us to again use an FEValues object to evaluate the shape functions at quadrature points, and with those also the values of a finite element function. For the example of the mixed Laplace problem above, consider the following code after solving:
/usr/share/doc/packages/dealii/doxygen/deal.II/index.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/index.html 2024-12-27 18:25:15.780921640 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/index.html 2024-12-27 18:25:15.784921667 +0000
@@ -132,7 +132,7 @@
DoFHandler: DoFHandler objects are the confluence of triangulations and finite elements: the finite element class describes how many degrees of freedom it needs per vertex, line, or cell, and the DoFHandler class allocates this space so that each vertex, line, or cell of the triangulation has the correct number of them. It also gives them a global numbering.
-
A different viewpoint is this: While the mesh and finite element describe abstract properties of the finite dimensional space in which we seek the discrete solution, the DoFHandler classes enumerate a concrete basis of this space so that we can represent the discrete solution as by an ordered set of coefficients .
+
A different viewpoint is this: While the mesh and finite element describe abstract properties of the finite dimensional space in which we seek the discrete solution, the DoFHandler classes enumerate a concrete basis of this space so that we can represent the discrete solution as by an ordered set of coefficients .
Just as with triangulation objects, most operations on DoFHandlers are done by looping over all cells and doing something on each or a subset of them. The interfaces of the two classes are therefore rather similar: they allow to get iterators to the first and last cell (or face, or line, etc) and offer information through these iterators. The information that can be gotten from these iterators is the geometric and topological information that can already be gotten from the triangulation iterators (they are in fact derived classes) as well as things like the global numbers of the degrees of freedom on the present cell. On can also ask an iterator to extract the values corresponding to the degrees of freedom on the present cell from a data vector that stores values for all degrees of freedom associated with a triangulation.
It is worth noting that, just as triangulations, DoFHandler classes do not know anything about the mapping from the unit cell to its individual cells. It is also ignorant of the shape functions that correspond to the degrees of freedom it manages: all it knows is that there are, for example, 2 degrees of freedom for each vertex and 4 per cell interior. Nothing about their specifics is relevant to the DoFHandler class with the exception of the fact that they exist.
The DoFHandler class and its associates are described in the Degrees of Freedom topic. In addition, there are specialized versions that can handle multilevel and hp-discretizations. These are described in the Multilevel support and hp-finite element support topics. Finite element methods frequently imply constraints on degrees of freedom, such as for hanging nodes or nodes at which boundary conditions apply; dealing with such constraints is described in the Constraints on degrees of freedom topic.
/usr/share/doc/packages/dealii/doxygen/deal.II/index__set_8h.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/index__set_8h.html 2024-12-27 18:25:15.808921832 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/index__set_8h.html 2024-12-27 18:25:15.808921832 +0000
@@ -155,7 +155,7 @@
-
Create and return an index set of size that contains every single index within this range. In essence, this function returns an index set created by
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Coarsening.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Coarsening.html 2024-12-27 18:25:15.836922024 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Coarsening.html 2024-12-27 18:25:15.836922024 +0000
@@ -145,11 +145,11 @@
const std::vector< value_type > &
children_values&#href_anchor"memdoc">
Check if data on all children match, and return value of the first child.
-
+\]" src="form_2234.png"/>
@@ -173,13 +173,13 @@
const std::vector< value_type > &
children_values&#href_anchor"memdoc">
Return sum of data on all children.
-
+\]" src="form_2235.png"/>
-
This strategy preserves the -norm of the corresponding global data vector before and after adaptation.
+
This strategy preserves the -norm of the corresponding global data vector before and after adaptation.
@@ -200,15 +200,15 @@
const std::vector< value_type > &
children_values&#href_anchor"memdoc">
-
Return -norm of data on all children.
+
Return -norm of data on all children.
-
+\]" src="form_2237.png"/>
-
This strategy preserves the -norm of the corresponding global data vector before and after adaptation.
+
This strategy preserves the -norm of the corresponding global data vector before and after adaptation.
@@ -231,11 +231,11 @@
const std::vector< value_type > &
children_values&#href_anchor"memdoc">
Return mean value of data on all children.
-
+\]" src="form_2238.png"/>
@@ -259,11 +259,11 @@
const std::vector< value_type > &
children_values&#href_anchor"memdoc">
Return maximum value of data on all children.
-
+\]" src="form_2239.png"/>
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Refinement.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Refinement.html 2024-12-27 18:25:15.860922189 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceAdaptationStrategies_1_1Refinement.html 2024-12-27 18:25:15.864922217 +0000
@@ -141,11 +141,11 @@
const value_type
parent_value&#href_anchor"memdoc">
Return a vector containing copies of data of the parent cell for each child.
-
+\]" src="form_2231.png"/>
@@ -169,13 +169,13 @@
const value_type
parent_value&#href_anchor"memdoc">
Return a vector which contains data of the parent cell being equally divided among all children.
-
+\]" src="form_2232.png"/>
-
This strategy preserves the -norm of the corresponding global data Vector before and after adaptation.
+
This strategy preserves the -norm of the corresponding global data Vector before and after adaptation.
@@ -198,13 +198,13 @@
const value_type
parent_value&#href_anchor"memdoc">
Return a vector which contains squared data of the parent cell being equally divided among the squares of all children.
-
+\]" src="form_2233.png"/>
-
This strategy preserves the -norm of the corresponding global data Vector before and after adaptation.
+
This strategy preserves the -norm of the corresponding global data Vector before and after adaptation.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataComponentInterpretation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataComponentInterpretation.html 2024-12-27 18:25:15.888922381 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataComponentInterpretation.html 2024-12-27 18:25:15.888922381 +0000
@@ -128,7 +128,7 @@
-
The members of this enum are used to describe the logical interpretation of what the various components of a vector-valued data set mean. For example, if one has a finite element for the Stokes equations in 2d, representing components , one would like to indicate that the first two, and , represent a logical vector so that later on when we generate graphical output we can hand them off to a visualization program that will automatically know to render them as a vector field, rather than as two separate and independent scalar fields.
+
The members of this enum are used to describe the logical interpretation of what the various components of a vector-valued data set mean. For example, if one has a finite element for the Stokes equations in 2d, representing components , one would like to indicate that the first two, and , represent a logical vector so that later on when we generate graphical output we can hand them off to a visualization program that will automatically know to render them as a vector field, rather than as two separate and independent scalar fields.
See the step-22 tutorial program for an example on how this information can be used in practice.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataOutBase.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataOutBase.html 2024-12-27 18:25:15.940922739 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDataOutBase.html 2024-12-27 18:25:15.944922766 +0000
@@ -551,7 +551,7 @@
While this discussion applies to two spatial dimensions, it is more complicated in 3d. The reason is that we could still use patches, but it is difficult when trying to visualize them, since if we use a cut through the data (by, for example, using x- and z-coordinates, a fixed y-value and plot function values in z-direction, then the patched data is not a patch in the sense GNUPLOT wants it any more. Therefore, we use another approach, namely writing the data on the 3d grid as a sequence of lines, i.e. two points each associated with one or more data sets. There are therefore 12 lines for each subcells of a patch.
Given the lines as described above, a cut through this data in Gnuplot can then be achieved like this:
* set data style lines
* splot [:][:][0:] "T" using 1:2:(\$3==.5 ? \$4 : -1)
-*
This command plots data in - and -direction unbounded, but in -direction only those data points which are above the - -plane (we assume here a positive solution, if it has negative values, you might want to decrease the lower bound). Furthermore, it only takes the data points with z-values (&3) equal to 0.5, i.e. a cut through the domain at z=0.5. For the data points on this plane, the data values of the first data set (&4) are raised in z-direction above the x-y-plane; all other points are denoted the value -1 instead of the value of the data vector and are not plotted due to the lower bound in z plotting direction, given in the third pair of brackets.
+*
This command plots data in - and -direction unbounded, but in -direction only those data points which are above the - -plane (we assume here a positive solution, if it has negative values, you might want to decrease the lower bound). Furthermore, it only takes the data points with z-values (&3) equal to 0.5, i.e. a cut through the domain at z=0.5. For the data points on this plane, the data values of the first data set (&4) are raised in z-direction above the x-y-plane; all other points are denoted the value -1 instead of the value of the data vector and are not plotted due to the lower bound in z plotting direction, given in the third pair of brackets.
More complex cuts are possible, including nonlinear ones. Note however, that only those points which are actually on the cut-surface are plotted.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDerivativeApproximation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDerivativeApproximation.html 2024-12-27 18:25:15.972922958 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDerivativeApproximation.html 2024-12-27 18:25:15.980923013 +0000
@@ -133,17 +133,17 @@
Detailed Description
This namespace provides functions that compute a cell-wise approximation of the norm of a derivative of a finite element field by taking difference quotients between neighboring cells. This is a rather simple but efficient form to get an error indicator, since it can be computed with relatively little numerical effort and yet gives a reasonable approximation.
-
The way the difference quotients are computed on cell is the following (here described for the approximation of the gradient of a finite element field, but see below for higher derivatives): let be a neighboring cell, and let be the distance vector between the centers of the two cells, then is an approximation of the directional derivative By multiplying both terms by from the left and summing over all neighbors , we obtain is the following (here described for the approximation of the gradient of a finite element field, but see below for higher derivatives): let be a neighboring cell, and let be the distance vector between the centers of the two cells, then is an approximation of the directional derivative By multiplying both terms by from the left and summing over all neighbors , we obtain
-
Thus, if the matrix is regular (which is the case when the vectors to all neighbors span the whole space), we can obtain an approximation to the true gradient by
+
Thus, if the matrix is regular (which is the case when the vectors to all neighbors span the whole space), we can obtain an approximation to the true gradient by This is a quantity that is easily computed. The value returned for each cell when calling the approximate_gradient function of this class is the norm of this approximation to the gradient. To make this a useful quantity, you may want to scale each element by the correct power of the respective cell size.
-
The computation of this quantity must fail if a cell has only neighbors for which the direction vectors do not span the whole space, since then the matrix is no longer invertible. If this happens, you will get an error similar to this one:
+\|y_{K'}\| } \right).$" src="form_2259.png"/> This is a quantity that is easily computed. The value returned for each cell when calling the approximate_gradient function of this class is the norm of this approximation to the gradient. To make this a useful quantity, you may want to scale each element by the correct power of the respective cell size.
+
The computation of this quantity must fail if a cell has only neighbors for which the direction vectors do not span the whole space, since then the matrix is no longer invertible. If this happens, you will get an error similar to this one:
As can easily be verified, this can only happen on very coarse grids, when some cells and all their neighbors have not been refined even once. You should therefore only call the functions of this class if all cells are at least once refined. In practice this is not much of a restriction.
Approximation of higher derivatives
-
Similar to the reasoning above, approximations to higher derivatives can be computed in a similar fashion. For example, the tensor of second derivatives is approximated by the formula where denotes the outer product of two vectors. Note that unlike the true tensor of second derivatives, its approximation is not necessarily symmetric. This is due to the fact that in the derivation, it is not clear whether we shall consider as projected second derivative the term or . Depending on which choice we take, we obtain one approximation of the tensor of second derivatives or its transpose. To avoid this ambiguity, as result we take the symmetrized form, which is the mean value of the approximation and its transpose.
-
The returned value on each cell is the spectral norm of the approximated tensor of second derivatives, i.e. the largest eigenvalue by absolute value. This equals the largest curvature of the finite element field at each cell, and the spectral norm is the matrix norm associated to the vector norm.
+- \nabla u_h(x_K)}{ \|y_{K'}\| } \right), $" src="form_2261.png"/> where denotes the outer product of two vectors. Note that unlike the true tensor of second derivatives, its approximation is not necessarily symmetric. This is due to the fact that in the derivation, it is not clear whether we shall consider as projected second derivative the term or . Depending on which choice we take, we obtain one approximation of the tensor of second derivatives or its transpose. To avoid this ambiguity, as result we take the symmetrized form, which is the mean value of the approximation and its transpose.
+
The returned value on each cell is the spectral norm of the approximated tensor of second derivatives, i.e. the largest eigenvalue by absolute value. This equals the largest curvature of the finite element field at each cell, and the spectral norm is the matrix norm associated to the vector norm.
Even higher than the second derivative can be obtained along the same lines as exposed above.
Refinement indicators based on the derivatives
-
If you would like to base a refinement criterion upon these approximation of the derivatives, you will have to scale the results of this class by an appropriate power of the mesh width. For example, since , it might be the right thing to scale the indicators as , i.e. , i.e. the right power is .
+
If you would like to base a refinement criterion upon these approximation of the derivatives, you will have to scale the results of this class by an appropriate power of the mesh width. For example, since , it might be the right thing to scale the indicators as , i.e. , i.e. the right power is .
Likewise, for the second derivative, one should choose a power of the mesh size one higher than for the gradient.
Implementation
-
The formulae for the computation of approximations to the gradient and to the tensor of second derivatives shown above are very much alike. The basic difference is that in one case the finite difference quotient is a scalar, while in the other case it is a vector. For higher derivatives, this would be a tensor of even higher rank. We then have to form the outer product of this difference quotient with the distance vector , symmetrize it, contract it with the matrix and compute its norm. To make the implementation simpler and to allow for code reuse, all these operations that are dependent on the actual order of the derivatives to be approximated, as well as the computation of the quantities entering the difference quotient, have been separated into auxiliary nested classes (names Gradient and SecondDerivative) and the main algorithm is simply passed one or the other data types and asks them to perform the order dependent operations. The main framework that is independent of this, such as finding all active neighbors, or setting up the matrix is done in the main function approximate.
+
The formulae for the computation of approximations to the gradient and to the tensor of second derivatives shown above are very much alike. The basic difference is that in one case the finite difference quotient is a scalar, while in the other case it is a vector. For higher derivatives, this would be a tensor of even higher rank. We then have to form the outer product of this difference quotient with the distance vector , symmetrize it, contract it with the matrix and compute its norm. To make the implementation simpler and to allow for code reuse, all these operations that are dependent on the actual order of the derivatives to be approximated, as well as the computation of the quantities entering the difference quotient, have been separated into auxiliary nested classes (names Gradient and SecondDerivative) and the main algorithm is simply passed one or the other data types and asks them to perform the order dependent operations. The main framework that is independent of this, such as finding all active neighbors, or setting up the matrix is done in the main function approximate.
Due to this way of operation, the class may be easily extended for higher order derivatives than are presently implemented. Basically, only an additional class along the lines of the derivative descriptor classes Gradient and SecondDerivative has to be implemented, with the respective alias and functions replaced by the appropriate analogues for the derivative that is to be approximated.
This function is the analogue to the one above, computing finite difference approximations of the tensor of second derivatives. Pass it the DoF handler object that describes the finite element field, a nodal value vector, and receive the cell-wise spectral norm of the approximated tensor of second derivatives. The spectral norm is the matrix norm associated to the vector norm.
+
This function is the analogue to the one above, computing finite difference approximations of the tensor of second derivatives. Pass it the DoF handler object that describes the finite element field, a nodal value vector, and receive the cell-wise spectral norm of the approximated tensor of second derivatives. The spectral norm is the matrix norm associated to the vector norm.
The last parameter denotes the solution component, for which the gradient is to be computed. It defaults to the first component. For scalar elements, this is the only valid choice; for vector-valued ones, any component between zero and the number of vector components can be given here.
In a parallel computation the solution vector needs to contain the locally relevant unknowns.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDifferentiation_1_1SD.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDifferentiation_1_1SD.html 2024-12-27 18:25:16.096923810 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDifferentiation_1_1SD.html 2024-12-27 18:25:16.104923865 +0000
@@ -2520,7 +2520,7 @@
Return an Expression representing a scalar symbolic variable with the identifier specified by symbol.
-
For example, if the symbol is the string "x" then the scalar symbolic variable that is returned represents the scalar .
+
For example, if the symbol is the string "x" then the scalar symbolic variable that is returned represents the scalar .
Parameters
[in]
symbol
An identifier (or name) for the returned symbolic variable.
@@ -3660,7 +3660,7 @@
Return a substitution map that has any explicit interdependencies between the entries of the input substitution_map resolved.
The force_cyclic_dependency_resolution flag exists to ensure, if desired, that no cyclic dependencies can exist in the returned map. If a cyclic dependency exists in the input substitution map, substitution_map, then with this flag set to true the dependency cycle is broken by a dictionary-ordered substitution. For example, if the substitution map contains two entries map["a"] -> "b" and map["b"] -> "a", then the result of calling this function would be a map with the elements map["a"] -> "a" and map["b"] -> "a".
If one symbol is an explicit function of another, and it is desired that all their values are completely resolved, then it may be necessary to perform substitution a number of times before the result is finalized. This function performs substitution sweeps for a set of symbolic variables until all explicit relationships between the symbols in the map have been resolved. Whether each entry returns a symbolic or real value depends on the nature of the values stored in the substitution map. If the values associated with a key are also symbolic then the returned result may still be symbolic in nature. The terminal result of using the input substitution map, symbol_values, is then guaranteed to be rendered by a single substitution of the returned dependency-resolved map.
-
Example: If map["a"] -> 1 and map["b"] -> "a"+ 2, then the function will be evaluated and the result is determined upon the completion of the first sweep. A second sweep is therefore necessary to resolve the final symbol, and the returned value is ultimately . By resolving the explicit relationships between all symbols in the map, we determine that map["a"] -> 1 and map["b"] -> 1 + 2 = 3 and thus, using only one substitution, that .
+
Example: If map["a"] -> 1 and map["b"] -> "a"+ 2, then the function will be evaluated and the result is determined upon the completion of the first sweep. A second sweep is therefore necessary to resolve the final symbol, and the returned value is ultimately . By resolving the explicit relationships between all symbols in the map, we determine that map["a"] -> 1 and map["b"] -> 1 + 2 = 3 and thus, using only one substitution, that .
@@ -3720,11 +3720,11 @@
If the symbols stored in the map are explicitly dependent on one another, then the returned result depends on the order in which the map is traversed. It is recommended to first resolve all interdependencies in the map using the resolve_explicit_dependencies() function.
Examples:
-
If map["a"] == 1 and map["b"] == "a" + 2, then the function will be evaluated and the result is returned. This return is because the symbol "a" is substituted throughout the function first, and only then is the symbol "b(a)" substituted, by which time its explicit dependency on "a" cannot be resolved.
+
If map["a"] == 1 and map["b"] == "a" + 2, then the function will be evaluated and the result is returned. This return is because the symbol "a" is substituted throughout the function first, and only then is the symbol "b(a)" substituted, by which time its explicit dependency on "a" cannot be resolved.
-If map["a"] == "b"+2 and map["b"] == 1, then the function will be evaluated and the result is returned. This is because the explicitly dependent symbol "a(b)" is substituted first followed by the symbol "b".
+If map["a"] == "b"+2 and map["b"] == 1, then the function will be evaluated and the result is returned. This is because the explicitly dependent symbol "a(b)" is substituted first followed by the symbol "b".
@@ -3875,7 +3875,7 @@
Return a vector of Expressions representing a vectorial symbolic variable with the identifier specified by symbol.
-
For example, if the symbol is the string "v" then the vectorial symbolic variable that is returned represents the vector . Each component of is prefixed by the given symbol, and has a suffix that indicates its component index.
+
For example, if the symbol is the string "v" then the vectorial symbolic variable that is returned represents the vector . Each component of is prefixed by the given symbol, and has a suffix that indicates its component index.
Template Parameters
dim
The dimension of the returned tensor.
@@ -3950,7 +3950,7 @@
Return a symmetric tensor of Expressions representing a tensorial symbolic variable with the identifier specified by symbol.
-
For example, if the symbol is the string "S" then the tensorial symbolic variable that is returned represents the vector . Each component of is prefixed by the given symbol, and has a suffix that indicates its component indices.
+
For example, if the symbol is the string "S" then the tensorial symbolic variable that is returned represents the vector . Each component of is prefixed by the given symbol, and has a suffix that indicates its component indices.
Template Parameters
rank
The rank of the returned tensor.
@@ -4115,7 +4115,7 @@
-
Returns
The tensor of symbolic functions or expressions representing the result .
+
Returns
The tensor of symbolic functions or expressions representing the result .
@@ -4144,7 +4144,7 @@
-
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
+
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
@@ -4173,7 +4173,7 @@
-
Returns
The tensor of symbolic functions or expressions representing the result .
+
Returns
The tensor of symbolic functions or expressions representing the result .
@@ -4202,7 +4202,7 @@
-
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
+
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
@@ -4231,7 +4231,7 @@
-
Returns
The tensor of symbolic functions or expressions representing the result .
+
Returns
The tensor of symbolic functions or expressions representing the result .
@@ -4260,7 +4260,7 @@
-
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
+
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
@@ -4289,7 +4289,7 @@
-
Returns
The tensor of symbolic functions or expressions representing the result .
+
Returns
The tensor of symbolic functions or expressions representing the result .
@@ -4318,7 +4318,7 @@
-
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
+
Returns
The symmetric tensor of symbolic functions or expressions representing the result .
@@ -4347,8 +4347,8 @@
-
Returns
The tensor of symbolic functions or variables representing the result .
+
Returns
The tensor of symbolic functions or variables representing the result .
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFRenumbering.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFRenumbering.html 2024-12-27 18:25:16.164924277 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFRenumbering.html 2024-12-27 18:25:16.168924304 +0000
@@ -236,13 +236,13 @@
Using the constraint information usually leads to reductions in bandwidth of 10 or 20 per cent, but may for some very unstructured grids also lead to an increase. You have to weigh the decrease in your case with the time spent to use the constraint information, which usually is several times longer than the ‘pure’ renumbering algorithm.
In almost all cases, the renumbering scheme finds a corner to start with. Since there is more than one corner in most grids and since even an interior degree of freedom may be a better starting point, giving the starting point by the user may be a viable way if you have a simple scheme to derive a suitable point (e.g. by successively taking the third child of the cell top left of the coarsest level, taking its third vertex and the dof index thereof, if you want the top left corner vertex). If you do not know beforehand what your grid will look like (e.g. when using adaptive algorithms), searching a best starting point may be difficult, however, and in many cases will not justify the effort.
Component-wise and block-wise numberings
-
For finite elements composed of several base elements using the FESystem class, or for elements which provide several components themselves, it may be of interest to sort the DoF indices by component. This will then bring out the block matrix structure, since otherwise the degrees of freedom are numbered cell-wise without taking into account that they may belong to different components. For example, one may want to sort degree of freedom for a Stokes discretization so that we first get all velocities and then all the pressures so that the resulting matrix naturally decomposes into a system.
+
For finite elements composed of several base elements using the FESystem class, or for elements which provide several components themselves, it may be of interest to sort the DoF indices by component. This will then bring out the block matrix structure, since otherwise the degrees of freedom are numbered cell-wise without taking into account that they may belong to different components. For example, one may want to sort degree of freedom for a Stokes discretization so that we first get all velocities and then all the pressures so that the resulting matrix naturally decomposes into a system.
This kind of numbering may be obtained by calling the component_wise() function of this class. Since it does not touch the order of indices within each component, it may be worthwhile to first renumber using the Cuthill-McKee or a similar algorithm and afterwards renumbering component-wise. This will bring out the matrix structure and additionally have a good numbering within each block.
The component_wise() function allows not only to honor enumeration based on vector components, but also allows to group together vector components into "blocks" using a defaulted argument to the various DoFRenumbering::component_wise() functions (see GlossComponent vs GlossBlock for a description of the difference). The blocks designated through this argument may, but do not have to be, equal to the blocks that the finite element reports. For example, a typical Stokes element would be
This element has dim+1 vector components and equally many blocks. However, one may want to consider the velocities as one logical block so that all velocity degrees of freedom are enumerated the same way, independent of whether they are - or -velocities. This is done, for example, in step-20 and step-22 as well as several other tutorial programs.
+
This element has dim+1 vector components and equally many blocks. However, one may want to consider the velocities as one logical block so that all velocity degrees of freedom are enumerated the same way, independent of whether they are - or -velocities. This is done, for example, in step-20 and step-22 as well as several other tutorial programs.
On the other hand, if you really want to use block structure reported by the finite element itself (a case that is often the case if you have finite elements that have multiple vector components, e.g. the FE_RaviartThomas or FE_Nedelec elements) then you can use the DoFRenumbering::block_wise instead of the DoFRenumbering::component_wise functions.
Cell-wise numbering
Given an ordered vector of cells, the function cell_wise() sorts the degrees of freedom such that degrees on earlier cells of this vector will occur before degrees on later cells.
@@ -255,7 +255,7 @@
The MatrixFree class provides optimized algorithms for interleaving operations on vectors before and after the access of the vector data in the respective loops. The algorithm matrix_free_data_locality() makes sure that all unknowns with a short distance between the first and last access are grouped together, in order to increase the spatial data locality.
A comparison of reordering strategies
As a benchmark of comparison, let us consider what the different sparsity patterns produced by the various algorithms when using the element combination typically employed in the discretization of Stokes equations, when used on the mesh obtained in step-22 after one adaptive mesh refinement in 3d. The space dimension together with the coupled finite element leads to a rather dense system matrix with, on average around 180 nonzero entries per row. After applying each of the reordering strategies shown below, the degrees of freedom are also sorted using DoFRenumbering::component_wise into velocity and pressure groups; this produces the block structure seen below with the large velocity-velocity block at top left, small pressure-pressure block at bottom right, and coupling blocks at top right and bottom left.
+Q_1$" src="form_991.png"/> element combination typically employed in the discretization of Stokes equations, when used on the mesh obtained in step-22 after one adaptive mesh refinement in 3d. The space dimension together with the coupled finite element leads to a rather dense system matrix with, on average around 180 nonzero entries per row. After applying each of the reordering strategies shown below, the degrees of freedom are also sorted using DoFRenumbering::component_wise into velocity and pressure groups; this produces the block structure seen below with the large velocity-velocity block at top left, small pressure-pressure block at bottom right, and coupling blocks at top right and bottom left.
The goal of reordering strategies is to improve the preconditioner. In step-22 we use a SparseILU to preconditioner for the velocity-velocity block at the top left. The quality of the preconditioner can then be measured by the number of CG iterations required to solve a linear system with this block. For some of the reordering strategies below we record this number for adaptive refinement cycle 3, with 93176 degrees of freedom; because we solve several linear systems with the same matrix in the Schur complement, the average number of iterations is reported. The lower the number the better the preconditioner and consequently the better the renumbering of degrees of freedom is suited for this task. We also state the run-time of the program, in part determined by the number of iterations needed, for the first 4 cycles on one of our machines. Note that the reported times correspond to the run time of the entire program, not just the affected solver; if a program runs twice as fast with one particular ordering than with another one, then this means that the actual solver is actually several times faster.
@@ -467,7 +467,7 @@
-
Sort the degrees of freedom by vector component. The numbering within each component is not touched, so a degree of freedom with index , belonging to some component, and another degree of freedom with index belonging to the same component will be assigned new indices and with if and if .
+
Sort the degrees of freedom by vector component. The numbering within each component is not touched, so a degree of freedom with index , belonging to some component, and another degree of freedom with index belonging to the same component will be assigned new indices and with if and if .
You can specify that the components are ordered in a different way than suggested by the FESystem object you use. To this end, set up the vector target_component such that the entry at index i denotes the number of the target component for dofs with component i in the FESystem. Naming the same target component more than once is possible and results in a blocking of several components into one. This is discussed in step-22. If you omit this argument, the same order as given by the finite element is used.
If one of the base finite elements from which the global finite element under consideration here, is a non-primitive one, i.e. its shape functions have more than one non-zero component, then it is not possible to associate these degrees of freedom with a single vector component. In this case, they are associated with the first vector component to which they belong.
For finite elements with only one component, or a single non-primitive base element, this function is the identity operation.
@@ -561,7 +561,7 @@
-
Sort the degrees of freedom by vector block. The numbering within each block is not touched, so a degree of freedom with index , belonging to some block, and another degree of freedom with index belonging to the same block will be assigned new indices and with if and if .
+
Sort the degrees of freedom by vector block. The numbering within each block is not touched, so a degree of freedom with index , belonging to some block, and another degree of freedom with index belonging to the same block will be assigned new indices and with if and if .
Note
This function only succeeds if each of the elements in the hp::FECollection attached to the DoFHandler argument has exactly the same number of blocks (see the glossary for more information). Note that this is not always given: while the hp::FECollection class ensures that all of its elements have the same number of vector components, they need not have the same number of blocks. At the same time, this function here needs to match individual blocks across elements and therefore requires that elements have the same number of blocks and that subsequent blocks in one element have the same meaning as in another element.
For meshes based on parallel::distributed::Triangulation, the locally owned cells of each MPI process are contiguous in Z order. That means that numbering degrees of freedom by visiting cells in Z order yields locally owned DoF indices that consist of contiguous ranges for each process. This is also true for the default ordering of DoFs on such triangulations, but the default ordering creates an enumeration that also depends on how many processors participate in the mesh, whereas the one generated by this function enumerates the degrees of freedom on a particular cell with indices that will be the same regardless of how many processes the mesh is split up between.
For meshes based on parallel::shared::Triangulation, the situation is more complex. Here, the set of locally owned cells is determined by a partitioning algorithm (selected by passing an object of type parallel::shared::Triangulation::Settings to the constructor of the triangulation), and in general these partitioning algorithms may assign cells to subdomains based on decisions that may have nothing to do with the Z order. (Though it is possible to select these flags in a way so that partitioning uses the Z order.) As a consequence, the cells of one subdomain are not contiguous in Z order, and if one renumbered degrees of freedom based on the Z order of cells, one would generally end up with DoF indices that on each processor do not form a contiguous range. This is often inconvenient (for example, because PETSc cannot store vectors and matrices for which the locally owned set of indices is not contiguous), and consequently this function uses the following algorithm for parallel::shared::Triangulation objects:
-
It determines how many degrees of freedom each processor owns. This is an invariant under renumbering, and consequently we can use how many DoFs each processor owns at the beginning of the current function. Let us call this number for processor .
+
It determines how many degrees of freedom each processor owns. This is an invariant under renumbering, and consequently we can use how many DoFs each processor owns at the beginning of the current function. Let us call this number for processor .
It determines for each processor a contiguous range of new DoF indices so that , , and .
It traverses the locally owned cells in Z order and renumbers the locally owned degrees of freedom on these cells so that the new numbers fit within the interval . In other words, the locally owned degrees of freedom on each processor are sorted according to the Z order of the locally owned cells they are on, but this property may not hold globally, across cells. This is because the partitioning algorithm may have decided that, for example, processor 0 owns a cell that comes later in Z order than one of the cells assigned to processor 1. On the other hand, the algorithm described above assigns the degrees of freedom on this cell earlier indices than all of the indices owned by processor 1.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFTools.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFTools.html 2024-12-27 18:25:16.248924853 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceDoFTools.html 2024-12-27 18:25:16.256924908 +0000
@@ -325,7 +325,7 @@
Setting up sparsity patterns for boundary matrices
In some cases, one wants to only work with DoFs that sit on the boundary. One application is, for example, if rather than interpolating non- homogeneous boundary values, one would like to project them. For this, we need two things: a way to identify nodes that are located on (parts of) the boundary, and a way to build matrices out of only degrees of freedom that are on the boundary (i.e. much smaller matrices, in which we do not even build the large zero block that stems from the fact that most degrees of freedom have no support on the boundary of the domain). The first of these tasks is done by the map_dof_to_boundary_indices() function (described above).
The second part requires us first to build a sparsity pattern for the couplings between boundary nodes, and then to actually build the components of this matrix. While actually computing the entries of these small boundary matrices is discussed in the MatrixCreator namespace, the creation of the sparsity pattern is done by the create_boundary_sparsity_pattern() function. For its work, it needs to have a numbering of all those degrees of freedom that are on those parts of the boundary that we are interested in. You can get this from the map_dof_to_boundary_indices() function. It then builds the sparsity pattern corresponding to integrals like , where and are indices into the matrix, and is the global DoF number of a degree of freedom sitting on a boundary (i.e., is the inverse of the mapping returned by map_dof_to_boundary_indices() function).
+\varphi_{b2d(i)} \varphi_{b2d(j)} dx$" src="form_1008.png"/>, where and are indices into the matrix, and is the global DoF number of a degree of freedom sitting on a boundary (i.e., is the inverse of the mapping returned by map_dof_to_boundary_indices() function).
DoF coupling between surface triangulations and bulk triangulations
When working with Triangulation and DoFHandler objects of different co-dimension, such as a Triangulation<2,3>, describing (part of) the boundary of a Triangulation<3>, and their corresponding DoFHandler objects, one often needs to build a one-to-one matching between the degrees of freedom that live on the surface Triangulation and those that live on the boundary of the bulk Triangulation. The GridGenerator::extract_boundary_mesh() function returns a mapping of surface cell iterators to face iterators, that can be used by the function map_boundary_to_bulk_dof_iterators() to construct a map between cell iterators of the surface DoFHandler, and the corresponding pair of cell iterator and face index of the bulk DoFHandler. Such map can be used to initialize FEValues and FEFaceValues for the corresponding DoFHandler objects. Notice that one must still ensure that the ordering of the quadrature points coincide in the two objects, in order to build a coupling matrix between the two sytesm.
Enumeration Type Documentation
@@ -500,7 +500,7 @@
Here, combined_orientation is the relative orientation of face_1 with respect to face_2. This is typically computed by GridTools::orthogonal_equality().
Optionally a matrix matrix along with a std::vector first_vector_components can be specified that describes how DoFs on face_1 should be modified prior to constraining to the DoFs of face_2. Here, two declarations are possible: If the std::vector first_vector_components is non empty the matrix is interpreted as a dimdim rotation matrix that is applied to all vector valued blocks listed in first_vector_components of the FESystem. If first_vector_components is empty the matrix is interpreted as an interpolation matrix with size no_face_dofs no_face_dofs.
This function makes sure that identity constraints don't create cycles in constraints.
-
periodicity_factor can be used to implement Bloch periodic conditions (a.k.a. phase shift periodic conditions) of the form where is periodic with the same periodicity as the crystal lattice and is the wavevector, see https://en.wikipedia.org/wiki/Bloch_wave. The solution at face_2 is equal to the solution at face_1 times periodicity_factor. For example, if the solution at face_1 is and is the corresponding point on face_2, then the solution at face_2 should be . This condition can be implemented using .
+
periodicity_factor can be used to implement Bloch periodic conditions (a.k.a. phase shift periodic conditions) of the form where is periodic with the same periodicity as the crystal lattice and is the wavevector, see https://en.wikipedia.org/wiki/Bloch_wave. The solution at face_2 is equal to the solution at face_1 times periodicity_factor. For example, if the solution at face_1 is and is the corresponding point on face_2, then the solution at face_2 should be . This condition can be implemented using .
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFESeries.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFESeries.html 2024-12-27 18:25:16.276925046 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFESeries.html 2024-12-27 18:25:16.280925073 +0000
@@ -178,7 +178,7 @@
-
Linear regression least-square fit of . The size of the input vectors should be equal and more than 1. The returned pair will contain (first) and (second).
+
Linear regression least-square fit of . The size of the input vectors should be equal and more than 1. The returned pair will contain (first) and (second).
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFETools.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFETools.html 2024-12-27 18:25:16.328925403 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFETools.html 2024-12-27 18:25:16.328925403 +0000
@@ -395,17 +395,17 @@
This is a rather specialized function used during the construction of finite element objects. It is used to build the basis of shape functions for an element, given a set of polynomials and interpolation points. The function is only implemented for finite elements with exactly dim vector components. In particular, this applies to classes derived from the FE_PolyTensor class.
-
Specifically, the purpose of this function is as follows: FE_PolyTensor receives, from its derived classes, an argument that describes a polynomial space. This space may be parameterized in terms of monomials, or in some other way, but is in general not in the form that we use for finite elements where we typically want to use a basis that is derived from some kind of node functional (e.g., the interpolation at specific points). Concretely, assume that the basis used by the polynomial space is , and that the node functionals of the finite element are . We then want to compute a basis for the finite element space so that . To do this, we can set where we need to determine the expansion coefficients . We do this by applying to both sides of the equation, to obtain
+
Specifically, the purpose of this function is as follows: FE_PolyTensor receives, from its derived classes, an argument that describes a polynomial space. This space may be parameterized in terms of monomials, or in some other way, but is in general not in the form that we use for finite elements where we typically want to use a basis that is derived from some kind of node functional (e.g., the interpolation at specific points). Concretely, assume that the basis used by the polynomial space is , and that the node functionals of the finite element are . We then want to compute a basis for the finite element space so that . To do this, we can set where we need to determine the expansion coefficients . We do this by applying to both sides of the equation, to obtain
-
and we know that the left hand side equals . If you think of this as a system of equations for the elements of a matrix on the left and on the right, then this can be written as
+
and we know that the left hand side equals . If you think of this as a system of equations for the elements of a matrix on the left and on the right, then this can be written as
-
where is the matrix of coefficients and . Consequently, in order to compute the expansion coefficients , we need to apply the node functionals to all functions of the "raw" basis of the polynomial space.
+
where is the matrix of coefficients and . Consequently, in order to compute the expansion coefficients , we need to apply the node functionals to all functions of the "raw" basis of the polynomial space.
Until the finite element receives this matrix back, it describes its shape functions (e.g., in FiniteElement::shape_value()) in the form . After it calls this function, it has the expansion coefficients and can describe its shape functions as .
This function therefore computes this matrix , for the following specific circumstances:
That the node functionals are point evaluations at points that the finite element in question describes via its "generalized" support points (through FiniteElement::get_generalized_support_points(), see also this glossary entry). These point evaluations need to necessarily evaluate the value of a shape function at that point (the shape function may be vector-valued, and so the functional may be a linear combination of the individual components of the values); but, in particular, the nodal functions may not be integrals over entire edges or faces, or other non-local functionals. In other words, we assume that where is a function of the (possibly vector-valued) argument that returns a scalar.
@@ -1058,7 +1058,7 @@
It then performs a loop over all non-active cells of dof2. If such a non-active cell has at least one active child, then we call the children of this cell a "patch". We then interpolate from the children of this patch to the patch, using the finite element space associated with dof2 and immediately interpolate back to the children. In essence, this information throws away all information in the solution vector that lives on a scale smaller than the patch cell.
Since we traverse non-active cells from the coarsest to the finest levels, we may find patches that correspond to child cells of previously treated patches if the mesh had been refined adaptively (this cannot happen if the mesh has been refined globally because there the children of a patch are all active). We also perform the operation described above on these patches, but it is easy to see that on patches that are children of previously treated patches, the operation is now the identity operation (since it interpolates from the children of the current patch a function that had previously been interpolated to these children from an even coarser patch). Consequently, this does not alter the solution vector any more.
-
The name of the function originates from the fact that it can be used to construct a representation of a function of higher polynomial degree on a once coarser mesh. For example, if you imagine that you start with a function on a globally refined mesh, and that dof2 is associated with a element, then this function computes the equivalent of the operator interpolating the original piecewise linear function onto a quadratic function on a once coarser mesh with mesh size (but representing this function on the original mesh with size ). If the exact solution is sufficiently smooth, then is typically a better approximation to the exact solution of the PDE than is. In other words, this function provides a postprocessing step that improves the solution in a similar way one often obtains by extrapolating a sequence of solutions, explaining the origin of the function's name.
+
The name of the function originates from the fact that it can be used to construct a representation of a function of higher polynomial degree on a once coarser mesh. For example, if you imagine that you start with a function on a globally refined mesh, and that dof2 is associated with a element, then this function computes the equivalent of the operator interpolating the original piecewise linear function onto a quadratic function on a once coarser mesh with mesh size (but representing this function on the original mesh with size ). If the exact solution is sufficiently smooth, then is typically a better approximation to the exact solution of the PDE than is. In other words, this function provides a postprocessing step that improves the solution in a similar way one often obtains by extrapolating a sequence of solutions, explaining the origin of the function's name.
Note
The resulting field does not satisfy continuity requirements of the given finite elements if the algorithm outlined above is used. When you use continuous elements on grids with hanging nodes, please use the extrapolate function with an additional AffineConstraints argument, see below.
Since this function operates on patches of cells, it requires that the underlying grid is refined at least once for every coarse grid cell. If this is not the case, an exception will be raised.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFiniteElementDomination.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFiniteElementDomination.html 2024-12-27 18:25:16.352925567 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFiniteElementDomination.html 2024-12-27 18:25:16.356925595 +0000
@@ -139,10 +139,10 @@
-
An enum that describes the outcome of comparing two elements for mutual domination. If one element dominates another, then the restriction of the space described by the dominated element to a face of the cell is strictly larger than that of the dominating element. For example, in 2-d Q(2) elements dominate Q(4) elements, because the traces of Q(4) elements are quartic polynomials which is a space strictly larger than the quadratic polynomials (the restriction of the Q(2) element). Similar reasonings apply for vertices and cells as well. In general, Q(k) dominates Q(k') if .
+
An enum that describes the outcome of comparing two elements for mutual domination. If one element dominates another, then the restriction of the space described by the dominated element to a face of the cell is strictly larger than that of the dominating element. For example, in 2-d Q(2) elements dominate Q(4) elements, because the traces of Q(4) elements are quartic polynomials which is a space strictly larger than the quadratic polynomials (the restriction of the Q(2) element). Similar reasonings apply for vertices and cells as well. In general, Q(k) dominates Q(k') if .
This enum is used in the FiniteElement::compare_for_domination() function that is used in the context of hp-finite element methods when determining what to do at faces where two different finite elements meet (see the hp-paper for a more detailed description of the following). In that case, the degrees of freedom of one side need to be constrained to those on the other side. The determination which side is which is based on the outcome of a comparison for mutual domination: the dominated side is constrained to the dominating one.
-
Note that there are situations where neither side dominates. The hp-paper lists two case, with the simpler one being that a vector-valued element (i.e. a FESystem(FE_Q(2),1,FE_Q(1),1)) meets a element: here, for each of the two vector-components, we can define a domination relationship, but it is different for the two components.
-
It is clear that the concept of domination doesn't matter for discontinuous elements. However, discontinuous elements may be part of vector-valued elements and may therefore be compared against each other for domination. They should return either_element_can_dominate in that case. Likewise, when comparing two identical finite elements, they should return this code; the reason is that we can not decide which element will dominate at the time we look at the first component of, for example, two and elements, and have to keep our options open until we get to the second base element.
+
Note that there are situations where neither side dominates. The hp-paper lists two case, with the simpler one being that a vector-valued element (i.e. a FESystem(FE_Q(2),1,FE_Q(1),1)) meets a element: here, for each of the two vector-components, we can define a domination relationship, but it is different for the two components.
+
It is clear that the concept of domination doesn't matter for discontinuous elements. However, discontinuous elements may be part of vector-valued elements and may therefore be compared against each other for domination. They should return either_element_can_dominate in that case. Likewise, when comparing two identical finite elements, they should return this code; the reason is that we can not decide which element will dominate at the time we look at the first component of, for example, two and elements, and have to keep our options open until we get to the second base element.
Finally, the code no_requirements exists for cases where elements impose no continuity requirements. The case is primarily meant for FE_Nothing which is an element that has no degrees of freedom in a subdomain. It could also be used by discontinuous elements, for example.
More details on domination can be found in the hp-paper.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFunctionTools.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFunctionTools.html 2024-12-27 18:25:16.376925732 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceFunctionTools.html 2024-12-27 18:25:16.380925760 +0000
@@ -143,12 +143,12 @@
Estimate bounds on the value and bounds on each gradient component of a Function, , over a BoundingBox, by approximating it by a 2nd order Taylor polynomial starting from the box center.
+
Estimate bounds on the value and bounds on each gradient component of a Function, , over a BoundingBox, by approximating it by a 2nd order Taylor polynomial starting from the box center.
Each lower and upper bound is returned as a std::pair<double, double>, such that the first entry is the lower bound, , and the second is the upper bound, , i.e. .
The function value, gradient, and Hessian are computed at the box center. The bounds on the value of the function are then estimated as
, where .
-
Here, is half the side length of the box in the th coordinate direction, which is the distance we extrapolate. The bounds on the gradient components are estimated similarly as
+
Here, is half the side length of the box in the th coordinate direction, which is the distance we extrapolate. The bounds on the gradient components are estimated similarly as
, where .
If the function has more than 1 component the component parameter can be used to specify which function component the bounds should be computed for.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridGenerator.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridGenerator.html 2024-12-27 18:25:16.472926391 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridGenerator.html 2024-12-27 18:25:16.480926446 +0000
@@ -281,7 +281,7 @@
Initialize the given triangulation with a hypercube (line in 1d, square in 2d, etc) consisting of exactly one cell. The hypercube volume is the tensor product interval in the present number of dimensions, where the limits are given as arguments. They default to zero and unity, then producing the unit hypercube.
+
Initialize the given triangulation with a hypercube (line in 1d, square in 2d, etc) consisting of exactly one cell. The hypercube volume is the tensor product interval in the present number of dimensions, where the limits are given as arguments. They default to zero and unity, then producing the unit hypercube.
If the argument colorize is false, then all boundary indicators are set to zero (the default boundary indicator) for 2d and 3d. If it is true, the boundary is colorized as in hyper_rectangle(). In 1d the indicators are always colorized, see hyper_rectangle().
Generate a grid consisting of a channel with a cylinder. This is a common benchmark for Navier-Stokes solvers. The geometry consists of a channel of size (where the dimension is omitted in 2d) with a cylinder, parallel to the axis with diameter , centered at . The channel has three distinct regions:
+
Generate a grid consisting of a channel with a cylinder. This is a common benchmark for Navier-Stokes solvers. The geometry consists of a channel of size (where the dimension is omitted in 2d) with a cylinder, parallel to the axis with diameter , centered at . The channel has three distinct regions:
If n_shells is greater than zero, then there are that many shells centered around the cylinder,
@@ -749,10 +749,10 @@
Parameters
tria
Triangulation to be created. Must be empty upon calling this function.
-
shell_region_width
Width of the layer of shells around the cylinder. This value should be between and ; the default value is .
+
shell_region_width
Width of the layer of shells around the cylinder. This value should be between and ; the default value is .
If true, then assign different boundary ids to different parts of the boundary. For more information on boundary indicators see this glossary entry. The left boundary (at ) is assigned an id of , the right boundary (at ) is assigned an id of ; the boundary of the obstacle in the middle (i.e., the circle in 2d or the cylinder walls in 3d) is assigned an id of , and the channel walls are assigned an id of .
+
colorize
If true, then assign different boundary ids to different parts of the boundary. For more information on boundary indicators see this glossary entry. The left boundary (at ) is assigned an id of , the right boundary (at ) is assigned an id of ; the boundary of the obstacle in the middle (i.e., the circle in 2d or the cylinder walls in 3d) is assigned an id of , and the channel walls are assigned an id of .
Generate a 2d mesh consisting of five squares arranged in a plus-shape. Depending on the number n_rotate_middle_square passed the middle square is rotated by a degree of n_rotate_middle_square. This way one can generate a mesh in which the middle square contains edges that have the opposite tangential and/or opposite normal orientation compared to the neighboring edges of the other squares.
+
Generate a 2d mesh consisting of five squares arranged in a plus-shape. Depending on the number n_rotate_middle_square passed the middle square is rotated by a degree of n_rotate_middle_square. This way one can generate a mesh in which the middle square contains edges that have the opposite tangential and/or opposite normal orientation compared to the neighboring edges of the other squares.
This mesh is not overly useful from a practical point of view. For debugging purposes it can be used to check for orientation issues for vector- or tensor-valued finite elements.
Generate a 3d mesh consisting of the unit cube joined with a copy shifted by . Depending on the flags passed either the right or the left cube (when looking at the positively oriented (x,z)-plane) contains a face that is either not in standard orientation and/or is rotated by either , or .
+
Generate a 3d mesh consisting of the unit cube joined with a copy shifted by . Depending on the flags passed either the right or the left cube (when looking at the positively oriented (x,z)-plane) contains a face that is either not in standard orientation and/or is rotated by either , or .
This mesh is not overly useful from a practical point of view. For debugging purposes it can be used to check for orientation issues for vector- or tensor-valued finite elements.
Parameters
@@ -1316,7 +1316,7 @@
const double
half_length = 1.&#href_anchor"memdoc">
-
Create a dim dimensional cylinder where the -axis serves as the axis of the cylinder. For the purposes of this function, a cylinder is defined as a (dim - 1) dimensional disk of given radius, extruded along the axis of the cylinder (which is the first coordinate direction). Consequently, in three dimensions, the cylinder extends from x=-half_length to x=+half_length and its projection into the yz-plane is a circle of radius radius. In two dimensions, the cylinder is a rectangle from x=-half_length to x=+half_length and from y=-radius to y=radius.
+
Create a dim dimensional cylinder where the -axis serves as the axis of the cylinder. For the purposes of this function, a cylinder is defined as a (dim - 1) dimensional disk of given radius, extruded along the axis of the cylinder (which is the first coordinate direction). Consequently, in three dimensions, the cylinder extends from x=-half_length to x=+half_length and its projection into the yz-plane is a circle of radius radius. In two dimensions, the cylinder is a rectangle from x=-half_length to x=+half_length and from y=-radius to y=radius.
The boundaries are colored according to the following scheme: 0 for the hull of the cylinder, 1 for the left hand face and 2 for the right hand face (see the glossary entry on colorization).
The manifold id for the hull of the cylinder is set to zero, and a CylindricalManifold is attached to it.
Precondition
The triangulation passed as argument needs to be empty when calling this function.
@@ -1351,7 +1351,7 @@
const double
half_length = 1.&#href_anchor"memdoc">
-
Create a dim dimensional cylinder where the -axis serves as the axis of the cylinder. For the purposes of this function, a cylinder is defined as a (dim - 1) dimensional disk of given radius, extruded along the axis of the cylinder (which is the first coordinate direction). Consequently, in three dimensions, the cylinder extends from x=-half_length to x=+half_length and its projection into the yz-plane is a circle of radius radius. In two dimensions, the cylinder is a rectangle from x=-half_length to x=+half_length and from y=-radius to y=radius. This function is only implemented for dim==3.
+
Create a dim dimensional cylinder where the -axis serves as the axis of the cylinder. For the purposes of this function, a cylinder is defined as a (dim - 1) dimensional disk of given radius, extruded along the axis of the cylinder (which is the first coordinate direction). Consequently, in three dimensions, the cylinder extends from x=-half_length to x=+half_length and its projection into the yz-plane is a circle of radius radius. In two dimensions, the cylinder is a rectangle from x=-half_length to x=+half_length and from y=-radius to y=radius. This function is only implemented for dim==3.
The boundaries are colored according to the following scheme: 0 for the hull of the cylinder, 1 for the left hand face and 2 for the right hand face (see the glossary entry on colorization).
The manifold id for the hull of the cylinder is set to zero, and a CylindricalManifold is attached to it.
@@ -1457,7 +1457,7 @@
tria
An empty triangulation which will hold the pipe junction geometry.
openings
Center point and radius of each of the three openings. The container has to be of size three.
bifurcation
Center point of the bifurcation and hypothetical radius of each truncated cone at the bifurcation.
-
aspect_ratio
Aspect ratio of cells, specified as radial over z-extension. Default ratio is .
+
aspect_ratio
Aspect ratio of cells, specified as radial over z-extension. Default ratio is .
A vector of integers of dimension GeometryInfo<dim>::faces_per_cell with the following meaning: the legs of the cross are stacked on the faces of the center cell, in the usual order of deal.II cells, namely first , then , then and so on. The corresponding entries in sizes name the number of cells stacked on this face. All numbers may be zero, thus L- and T-shaped domains are specializations of this domain.
+
sizes
A vector of integers of dimension GeometryInfo<dim>::faces_per_cell with the following meaning: the legs of the cross are stacked on the faces of the center cell, in the usual order of deal.II cells, namely first , then , then and so on. The corresponding entries in sizes name the number of cells stacked on this face. All numbers may be zero, thus L- and T-shaped domains are specializations of this domain.
colorize_cells
If colorization is enabled, then the material id of a cells corresponds to the leg it is in. The id of the center cell is zero, and then the legs are numbered starting at one (see the glossary entry on colorization).
@@ -1738,9 +1738,9 @@
96 for the rhombic dodecahedron refined once. This choice dates from an older version of deal.II before the Manifold classes were implemented: today this choce is equivalent to the rhombic dodecahedron after performing one global refinement.
-Numbers of the kind with integer. This choice is similar to the 24 and 48 cell cases, but provides additional refinements in azimuthal direction combined with a single layer in radial direction. The base mesh is either the 6 or 12 cell version, depending on whether in the power is odd or even, respectively.
+Numbers of the kind with integer. This choice is similar to the 24 and 48 cell cases, but provides additional refinements in azimuthal direction combined with a single layer in radial direction. The base mesh is either the 6 or 12 cell version, depending on whether in the power is odd or even, respectively.
-
The versions with 24, 48, and cells are useful if the shell is thin and the radial lengths should be made more similar to the circumferential lengths.
+
The versions with 24, 48, and cells are useful if the shell is thin and the radial lengths should be made more similar to the circumferential lengths.
The 3d grids with 12 and 96 cells are plotted below:
Produce a domain that is the intersection between a hyper-shell with given inner and outer radius, i.e. the space between two circles in two space dimensions and the region between two spheres in 3d, and the positive quadrant (in 2d) or octant (in 3d). In 2d, this is indeed a quarter of the full annulus, while the function is a misnomer in 3d because there the domain is not a quarter but one eighth of the full shell.
If the number of initial cells is zero (as is the default), then it is computed adaptively such that the resulting elements have the least aspect ratio in 2d.
-
If colorize is set to true, the inner, outer, left, and right boundary get indicator 0, 1, 2, and 3 in 2d, respectively. Otherwise all indicators are set to 0. In 3d indicator 2 is at the face , 3 at , 4 at (see the glossary entry on colorization).
+
If colorize is set to true, the inner, outer, left, and right boundary get indicator 0, 1, 2, and 3 in 2d, respectively. Otherwise all indicators are set to 0. In 3d indicator 2 is at the face , 3 at , 4 at (see the glossary entry on colorization).
All manifold ids are set to zero, and a SphericalManifold is attached to the triangulation.
Precondition
The triangulation passed as argument needs to be empty when calling this function.
Produce a domain that is the space between two cylinders in 3d, with given length, inner and outer radius and a given number of elements. The cylinder shell is built around the -axis with the two faces located at and length.
+
Produce a domain that is the space between two cylinders in 3d, with given length, inner and outer radius and a given number of elements. The cylinder shell is built around the -axis with the two faces located at and length.
If n_radial_cells is zero (as is the default), then it is computed adaptively such that the resulting elements have the least aspect ratio. The same holds for n_axial_cells.
If colorize is set to true, a boundary id of 0 is set for the inner cylinder, a boundary id of 1 is set for the outer cylinder, a boundary id of 2 is set for the bottom (z-) boundary and a boundary id of 3 is set for the top (z+) boundary.
Note
Although this function is declared as a template, it does not make sense in 1d and 2d. Also keep in mind that this object is rotated and positioned differently than the one created by cylinder().
@@ -1989,9 +1989,9 @@
-
Produce the volume or surface mesh of a torus. The axis of the torus is the -axis while the plane of the torus is the - plane.
+
Produce the volume or surface mesh of a torus. The axis of the torus is the -axis while the plane of the torus is the - plane.
If dim is 3, the mesh will be the volume of the torus, using a mesh equivalent to the circle in the poloidal coordinates with 5 cells on the cross section. This function attaches a TorusManifold to all boundary faces which are marked with a manifold id of 1, a CylindricalManifold to the interior cells and all their faces which are marked with a manifold id of 2 (representing a flat state within the poloidal coordinates), and a TransfiniteInterpolationManifold to the cells between the TorusManifold on the surface and the ToroidalManifold in the center, with cells marked with manifold id 0.
-
An example for the case if dim is 3 with a cut through the domain at , 6 toroidal cells, and without any global refinement is given here:
+
An example for the case if dim is 3 with a cut through the domain at , 6 toroidal cells, and without any global refinement is given here:
@@ -2003,7 +2003,7 @@
centerline_radius
The radius of the circle which forms the center line of the torus containing the loop of cells. Must be greater than inner_radius.
inner_radius
The distance between the inner edge of the torus and origin.
n_cells_toroidal
Optional argument to set the number of cell layers in toroidal direction. The default is 6 cell layers.
-
phi
Optional argument to generate an open torus with angle . The default value is , in which case a closed torus is generated. If the torus is open, the torus is cut at two planes perpendicular to the torus centerline. The center of these two planes are located at and .
+
phi
Optional argument to generate an open torus with angle . The default value is , in which case a closed torus is generated. If the torus is open, the torus is cut at two planes perpendicular to the torus centerline. The center of these two planes are located at and .
@@ -2048,8 +2048,8 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridRefinement.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridRefinement.html 2024-12-27 18:25:16.512926666 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceGridRefinement.html 2024-12-27 18:25:16.520926721 +0000
@@ -340,12 +340,12 @@
This function flags cells of a triangulation for refinement with the aim to reach a grid that is optimal with respect to an objective function that tries to balance reducing the error and increasing the numerical cost when the mesh is refined. Specifically, this function makes the assumption that if you refine a cell with error indicator provided by the second argument to this function, then the error on the children (for all children together) will only be where order is the third argument of this function. This makes the assumption that the error is only a local property on a mesh and can be reduced by local refinement – an assumption that is true for the interpolation operator, but not for the usual Galerkin projection, although it is approximately true for elliptic problems where the Greens function decays quickly and the error here is not too much affected by a too coarse mesh somewhere else.
-
With this, we can define the objective function this function tries to optimize. Let us assume that the mesh currently has cells. Then, if we refine the cells with the largest errors, we expect to get (in space dimensions)
+
With this, we can define the objective function this function tries to optimize. Let us assume that the mesh currently has cells. Then, if we refine the cells with the largest errors, we expect to get (in space dimensions)
-
cells ( are not refined, and each of the cells we refine yield child cells. On the other hand, with refining cells, and using the assumptions above, we expect that the error will be
+
cells ( are not refined, and each of the cells we refine yield child cells. On the other hand, with refining cells, and using the assumptions above, we expect that the error will be
-
where the first sum extends over cells and the second over the cells that will be refined. Note that is an increasing function of whereas is a decreasing function.
-
This function then tries to find that number of cells to mark for refinement for which the objective function
+
where the first sum extends over cells and the second over the cells that will be refined. Note that is an increasing function of whereas is a decreasing function.
+
This function then tries to find that number of cells to mark for refinement for which the objective function
@@ -364,7 +364,7 @@
The rationale for this function is two-fold. First, compared to the refine_and_coarsen_fixed_fraction() and refine_and_coarsen_fixed_number() functions, this function has the property that if all refinement indicators are the same (i.e., we have achieved a mesh where the error per cell is equilibrated), then the entire mesh is refined. This is based on the observation that a mesh with equilibrated error indicators is the optimal mesh (i.e., has the least overall error) among all meshes with the same number of cells. (For proofs of this, see R. Becker, M. Braack, R. Rannacher: "Numerical simulation of laminar flames at low Mach number
with adaptive finite elements", Combustion Theory and Modelling, Vol. 3, Nr. 3, p. 503-534 1999; and W. Bangerth, R. Rannacher: "Adaptive Finite
Element Methods for Differential Equations", Birkhauser, 2003.)
-
Second, the function uses the observation that ideally, the error behaves like with some constant that depends on the dimension and the finite element degree. It should - given optimal mesh refinement - not depend so much on the regularity of the solution, as it is based on the idea, that all singularities can be resolved by refinement. Mesh refinement is then based on the idea that we want to make small. This corresponds to the functional above.
+
Second, the function uses the observation that ideally, the error behaves like with some constant that depends on the dimension and the finite element degree. It should - given optimal mesh refinement - not depend so much on the regularity of the solution, as it is based on the idea, that all singularities can be resolved by refinement. Mesh refinement is then based on the idea that we want to make small. This corresponds to the functional above.
Note
This function was originally implemented by Thomas Richter. It follows a strategy described in [Richter2005]. See in particular Section 4.3, pp. 42-43.
Transform the vertices of the given triangulation by applying the function object provided as first argument to all its vertices.
-
The transformation given as argument is used to transform each vertex. Its respective type has to offer a function-like syntax, i.e. the predicate is either an object of a type that has an operator(), or it is a pointer to a non-member function, or it is a lambda function object. In either case, argument and return value have to be of type Point<spacedim>. An example – a simple transformation that moves the object two units to the right in the direction – could look like as follows:
The transformation given as argument is used to transform each vertex. Its respective type has to offer a function-like syntax, i.e. the predicate is either an object of a type that has an operator(), or it is a pointer to a non-member function, or it is a lambda function object. In either case, argument and return value have to be of type Point<spacedim>. An example – a simple transformation that moves the object two units to the right in the direction – could look like as follows:
Transform the given triangulation smoothly to a different domain where, typically, each of the vertices at the boundary of the triangulation is mapped to the corresponding points in the new_points map.
-
The unknown displacement field in direction is obtained from the minimization problem
- in direction is obtained from the minimization problem
+
+\]" src="form_1463.png"/>
subject to prescribed constraints. The minimizer is obtained by solving the Laplace equation of the dim components of a displacement field that maps the current domain into one described by new_points . Linear finite elements with four Gaussian quadrature points in each direction are used. The difference between the vertex positions specified in new_points and their current value in tria therefore represents the prescribed values of this displacement field at the boundary of the domain, or more precisely at all of those locations for which new_points provides values (which may be at part of the boundary, or even in the interior of the domain). The function then evaluates this displacement field at each unconstrained vertex and uses it to place the mapped vertex where the displacement field locates it. Because the solution of the Laplace equation is smooth, this guarantees a smooth mapping from the old domain to the new one.
Parameters
@@ -2126,7 +2126,7 @@
This function does the same as the previous one, i.e. it partitions a triangulation using a partitioning algorithm into a number of subdomains identified by the cell->subdomain_id() flag.
The difference to the previous function is the second argument, a sparsity pattern that represents the connectivity pattern between cells.
-
While the function above builds it directly from the triangulation by considering which cells neighbor each other, this function can take a more refined connectivity graph. The sparsity pattern needs to be of size , where is the number of active cells in the triangulation. If the sparsity pattern contains an entry at position , then this means that cells and (in the order in which they are traversed by active cell iterators) are to be considered connected; partitioning algorithm will then try to partition the domain in such a way that (i) the subdomains are of roughly equal size, and (ii) a minimal number of connections are broken.
+
While the function above builds it directly from the triangulation by considering which cells neighbor each other, this function can take a more refined connectivity graph. The sparsity pattern needs to be of size , where is the number of active cells in the triangulation. If the sparsity pattern contains an entry at position , then this means that cells and (in the order in which they are traversed by active cell iterators) are to be considered connected; partitioning algorithm will then try to partition the domain in such a way that (i) the subdomains are of roughly equal size, and (ii) a minimal number of connections are broken.
This function is mainly useful in cases where connections between cells exist that are not present in the triangulation alone (otherwise the previous function would be the simpler one to use). Such connections may include that certain parts of the boundary of a domain are coupled through symmetric boundary conditions or integrals (e.g. friction contact between the two sides of a crack in the domain), or if a numerical scheme is used that not only connects immediate neighbors but a larger neighborhood of cells (e.g. when solving integral equations).
In addition, this function may be useful in cases where the default sparsity pattern is not entirely sufficient. This can happen because the default is to just consider face neighbors, not neighboring cells that are connected by edges or vertices. While the latter couple when using continuous finite elements, they are typically still closely connected in the neighborship graph, and partitioning algorithm will not usually cut important connections in this case. However, if there are vertices in the mesh where many cells (many more than the common 4 or 6 in 2d and 3d, respectively) come together, then there will be a significant number of cells that are connected across a vertex, but several degrees removed in the connectivity graph built only using face neighbors. In a case like this, partitioning algorithm may sometimes make bad decisions and you may want to build your own connectivity graph.
Note
If the weight signal has been attached to the triangulation, then this will be used and passed to the partitioner.
face1 and face2 are considered equal, if a one to one matching between its vertices can be achieved via an orthogonal equality relation. If no such relation exists then the returned std::optional object is empty (i.e., has_value() will return false).
-
Here, two vertices v_1 and v_2 are considered equal, if is parallel to the unit vector in unit direction direction. If the parameter matrix is a reference to a spacedim x spacedim matrix, is set to matrix, otherwise is the identity matrix.
+
Here, two vertices v_1 and v_2 are considered equal, if is parallel to the unit vector in unit direction direction. If the parameter matrix is a reference to a spacedim x spacedim matrix, is set to matrix, otherwise is the identity matrix.
If the matching was successful, the relative orientation of face1 with respect to face2 is returned a std::optional<unsigned char>, in which the stored value is the same orientation bit format used elsewhere in the library. More information on that topic can be found in the glossary article.
This function tries to match all faces belonging to the first boundary with faces belonging to the second boundary with the help of orthogonal_equality().
The unsigned char that is returned inside of PeriodicFacePair encodes the relative orientation of the first face with respect to the second face, see the documentation of orthogonal_equality() for further details.
The direction refers to the space direction in which periodicity is enforced. When matching periodic faces this vector component is ignored.
-
The offset is a vector tangential to the faces that is added to the location of vertices of the 'first' boundary when attempting to match them to the corresponding vertices of the 'second' boundary. This can be used to implement conditions such as .
-
Optionally, a rotation matrix can be specified that describes how vector valued DoFs of the first face should be modified prior to constraining to the DoFs of the second face. The matrix is used in two places. First, matrix will be supplied to orthogonal_equality() and used for matching faces: Two vertices and match if is parallel to the unit vector in unit direction direction. (For more details see DoFTools::make_periodicity_constraints(), the glossary glossary entry on periodic conditions and step-45). Second, matrix will be stored in the PeriodicFacePair collection matched_pairs for further use.
+
The offset is a vector tangential to the faces that is added to the location of vertices of the 'first' boundary when attempting to match them to the corresponding vertices of the 'second' boundary. This can be used to implement conditions such as .
+
Optionally, a rotation matrix can be specified that describes how vector valued DoFs of the first face should be modified prior to constraining to the DoFs of the second face. The matrix is used in two places. First, matrix will be supplied to orthogonal_equality() and used for matching faces: Two vertices and match if is parallel to the unit vector in unit direction direction. (For more details see DoFTools::make_periodicity_constraints(), the glossary glossary entry on periodic conditions and step-45). Second, matrix will be stored in the PeriodicFacePair collection matched_pairs for further use.
Compute the volume (i.e. the dim-dimensional measure) of the triangulation. We compute the measure using the integral where are the cells of the given triangulation. The integral is approximated via quadrature. This version of the function uses a linear mapping to compute the JxW values on each cell.
+
Compute the volume (i.e. the dim-dimensional measure) of the triangulation. We compute the measure using the integral where are the cells of the given triangulation. The integral is approximated via quadrature. This version of the function uses a linear mapping to compute the JxW values on each cell.
If the triangulation is a dim-dimensional one embedded in a higher dimensional space of dimension spacedim, then the value returned is the dim-dimensional measure. For example, for a two-dimensional triangulation in three-dimensional space, the value returned is the area of the surface so described. (This obviously makes sense since the spacedim-dimensional measure of a dim-dimensional triangulation would always be zero if dim < spacedim).
Compute the volume (i.e. the dim-dimensional measure) of the triangulation. We compute the measure using the integral where are the cells of the given triangulation. The integral is approximated via quadrature for which we use the mapping argument.
+
Compute the volume (i.e. the dim-dimensional measure) of the triangulation. We compute the measure using the integral where are the cells of the given triangulation. The integral is approximated via quadrature for which we use the mapping argument.
If the triangulation is a dim-dimensional one embedded in a higher dimensional space of dimension spacedim, then the value returned is the dim-dimensional measure. For example, for a two-dimensional triangulation in three-dimensional space, the value returned is the area of the surface so described. (This obviously makes sense since the spacedim-dimensional measure of a dim-dimensional triangulation would always be zero if dim < spacedim.
This function computes an affine approximation of the map from the unit coordinates to the real coordinates of the form by a least squares fit of this affine function to the vertices representing a quadrilateral or hexahedral cell in spacedim dimensions. The result is returned as a pair with the matrix A as the first argument and the vector b describing distance of the plane to the origin.
+
This function computes an affine approximation of the map from the unit coordinates to the real coordinates of the form by a least squares fit of this affine function to the vertices representing a quadrilateral or hexahedral cell in spacedim dimensions. The result is returned as a pair with the matrix A as the first argument and the vector b describing distance of the plane to the origin.
For any valid mesh cell whose geometry is not degenerate, this operation results in a unique affine mapping, even in cases where the actual transformation by a bi-/trilinear or higher order mapping might be singular. The result is exact in case the transformation from the unit to the real cell is indeed affine, such as in one dimension or for Cartesian and affine (parallelogram) meshes in 2d/3d.
Computes an aspect ratio measure for all locally-owned active cells and fills a vector with one entry per cell, given a triangulation and mapping. The size of the vector that is returned equals the number of active cells. The vector contains zero for non locally-owned cells. The aspect ratio of a cell is defined as the ratio of the maximum to minimum singular value of the Jacobian, taking the maximum over all quadrature points of a quadrature rule specified via quadrature. For example, for the special case of rectangular elements in 2d with dimensions and ( ), this function returns the usual aspect ratio definition . The above definition using singular values is a generalization to arbitrarily deformed elements. This function is intended to be used for space dimensions, but it can also be used for returning a value of 1.
+
Computes an aspect ratio measure for all locally-owned active cells and fills a vector with one entry per cell, given a triangulation and mapping. The size of the vector that is returned equals the number of active cells. The vector contains zero for non locally-owned cells. The aspect ratio of a cell is defined as the ratio of the maximum to minimum singular value of the Jacobian, taking the maximum over all quadrature points of a quadrature rule specified via quadrature. For example, for the special case of rectangular elements in 2d with dimensions and ( ), this function returns the usual aspect ratio definition . The above definition using singular values is a generalization to arbitrarily deformed elements. This function is intended to be used for space dimensions, but it can also be used for returning a value of 1.
Note
Inverted elements do not throw an exception. Instead, a value of inf is written into the vector in case of inverted elements.
Make sure to use enough quadrature points for a precise calculation of the aspect ratio in case of deformed elements.
@@ -3537,7 +3537,7 @@
const double
tol = 1e-12&#href_anchor"memdoc">
Remove vertices that are duplicated, due to the input of a structured grid, for example. If these vertices are not removed, the faces bounded by these vertices become part of the boundary, even if they are in the interior of the mesh.
-
This function is called by some GridIn::read_* functions. Only the vertices with indices in considered_vertices are tested for equality. This speeds up the algorithm, which is, for worst-case hyper cube geometries in 2d and in 3d: quite slow. However, if you wish to consider all vertices, simply pass an empty vector. In that case, the function fills considered_vertices with all vertices.
+
This function is called by some GridIn::read_* functions. Only the vertices with indices in considered_vertices are tested for equality. This speeds up the algorithm, which is, for worst-case hyper cube geometries in 2d and in 3d: quite slow. However, if you wish to consider all vertices, simply pass an empty vector. In that case, the function fills considered_vertices with all vertices.
Two vertices are considered equal if their difference in each coordinate direction is less than tol. This implies that nothing happens if the tolerance is set to zero.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLineMinimization.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLineMinimization.html 2024-12-27 18:25:16.668927737 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLineMinimization.html 2024-12-27 18:25:16.672927765 +0000
@@ -161,7 +161,7 @@
-
Given and together with values of function and and the gradient , return the local minimizer of the quadratic interpolation function.
+
Given and together with values of function and and the gradient , return the local minimizer of the quadratic interpolation function.
The return type is optional to fit with similar functions that may not have a solution for given parameters.
@@ -206,7 +206,7 @@
-
Given and together with values of function and and its gradients ( ) at those points, return the local minimizer of the cubic interpolation function (that is, the location where the cubic interpolation function attains its minimum value).
+
Given and together with values of function and and its gradients ( ) at those points, return the local minimizer of the cubic interpolation function (that is, the location where the cubic interpolation function attains its minimum value).
The return type is optional as the real-valued solution might not exist.
@@ -256,7 +256,7 @@
-
Find the minimizer of a cubic polynomial that goes through the points , and and has derivatve at .
+
Find the minimizer of a cubic polynomial that goes through the points , and and has derivatve at .
The return type is optional as the real-valued solution might not exist.
Perform a line search in with strong Wolfe conditions
- with strong Wolfe conditions
+
+\]" src="form_2502.png"/>
using the one dimensional function func in conjunction with a function interpolate to choose a new point from the interval based on the function values and derivatives at its ends. The parameter a1 is a trial estimate of the first step. Interpolation can be done using either poly_fit() or poly_fit_three_points(), or any other function that has a similar signature.
The function implements Algorithms 2.6.2 and 2.6.4 on pages 34-35 in [Fletcher2013]. These are minor variations of Algorithms 3.5 and 3.6 on pages 60-61 in [Nocedal2006]. It consists of a bracketing phase and a zoom phase, where interpolate is used.
-
Two examples of use might be as follows: In the first example, we wish to find the minimum of the function . To find the approximate solution using line search with a polynomial fit to the curve one would perform the following steps:
+
Two examples of use might be as follows: In the first example, we wish to find the minimum of the function . To find the approximate solution using line search with a polynomial fit to the curve one would perform the following steps:
auto func = [](constdouble x)
{
constdouble f = 100. * std::pow(x, 4) + std::pow(1. - x, 2); // Value
@@ -570,7 +570,7 @@
func
A one dimensional function which returns value and derivative at the given point.
f0
The function value at the origin.
g0
The function derivative at the origin.
-
interpolate
A function which determines how interpolation is done during the zoom phase. It takes values and derivatives at the current interval/bracket ( , ) as well as up to 5 values and derivatives at previous steps. The returned value is to be provided within the given bounds.
+
interpolate
A function which determines how interpolation is done during the zoom phase. It takes values and derivatives at the current interval/bracket ( , ) as well as up to 5 values and derivatives at previous steps. The returned value is to be provided within the given bounds.
a1
Initial trial step for the bracketing phase.
eta
A parameter in the second Wolfe condition (curvature condition).
mu
A parameter in the first Wolfe condition (sufficient decrease).
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators.html 2024-12-27 18:25:16.700927957 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators.html 2024-12-27 18:25:16.704927984 +0000
@@ -141,9 +141,9 @@
The namespace L2 contains functions for mass matrices and L2-inner products.
Notational conventions
In most cases, the action of a function in this namespace can be described by a single integral. We distinguish between integrals over cells Z and over faces F. If an integral is denoted as
-
+\]" src="form_1639.png"/>
it will yield the following results, depending on the type of operation
@@ -153,7 +153,7 @@
If the function returns a number, then this number is the integral of the two given functions u and v.
-
We will use regular cursive symbols for scalars and bold symbols for vectors. Test functions are always v and trial functions are always u. Parameters are Greek and the face normal vectors are .
+
We will use regular cursive symbols for scalars and bold symbols for vectors. Test functions are always v and trial functions are always u. Parameters are Greek and the face normal vectors are .
Signature of functions
Functions in this namespace follow a generic signature. In the simplest case, you have two related functions
template <int dim>
void
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Advection.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Advection.html 2024-12-27 18:25:16.736928204 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Advection.html 2024-12-27 18:25:16.740928232 +0000
@@ -175,8 +175,8 @@
const double
factor = 1.&#href_anchor"memdoc">
Advection along the direction w in weak form with derivative on the test function
-
+
The FiniteElement in fe may be scalar or vector valued. In the latter case, the advection operator is applied to each component separately.
Parameters
@@ -235,7 +235,7 @@
Scalar advection residual operator in strong form
-
+
Warning
This is not the residual consistent with cell_matrix(), but with its transpose.
@@ -284,8 +284,8 @@
Vector-valued advection residual operator in strong form
-
+
Warning
This is not the residual consistent with cell_matrix(), but with its transpose.
Upwind flux at the boundary for weak advection operator. This is the value of the trial function at the outflow boundary and zero else:
-
+\]" src="form_1593.png"/>
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected by the same velocity.
@@ -481,13 +481,13 @@
Scalar case: Residual for upwind flux at the boundary for weak advection operator. This is the value of the trial function at the outflow boundary and the value of the incoming boundary condition on the inflow boundary:
-
+\]" src="form_1594.png"/>
-
Here, the numerical flux is the upwind value at the face, namely the finite element function whose values are given in the argument input on the outflow boundary. On the inflow boundary, it is the inhomogeneous boundary value in the argument data.
+
Here, the numerical flux is the upwind value at the face, namely the finite element function whose values are given in the argument input on the outflow boundary. On the inflow boundary, it is the inhomogeneous boundary value in the argument data.
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected by the same velocity.
@@ -540,13 +540,13 @@
Vector-valued case: Residual for upwind flux at the boundary for weak advection operator. This is the value of the trial function at the outflow boundary and the value of the incoming boundary condition on the inflow boundary:
-
+\]" src="form_1594.png"/>
-
Here, the numerical flux is the upwind value at the face, namely the finite element function whose values are given in the argument input on the outflow boundary. On the inflow boundary, it is the inhomogeneous boundary value in the argument data.
+
Here, the numerical flux is the upwind value at the face, namely the finite element function whose values are given in the argument input on the outflow boundary. On the inflow boundary, it is the inhomogeneous boundary value in the argument data.
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected by the same velocity.
@@ -612,13 +612,13 @@
const double
factor = 1.&#href_anchor"memdoc">
Upwind flux in the interior for weak advection operator. Matrix entries correspond to the upwind value of the trial function, multiplied by the jump of the test functions
-
+\]" src="form_1596.png"/>
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected the same way.
@@ -675,13 +675,13 @@
const double
factor = 1.&#href_anchor"memdoc">
Scalar case: Upwind flux in the interior for weak advection operator. Matrix entries correspond to the upwind value of the trial function, multiplied by the jump of the test functions
-
+\]" src="form_1596.png"/>
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected the same way.
@@ -738,13 +738,13 @@
const double
factor = 1.&#href_anchor"memdoc">
Vector-valued case: Upwind flux in the interior for weak advection operator. Matrix entries correspond to the upwind value of the trial function, multiplied by the jump of the test functions
-
+\]" src="form_1596.png"/>
The velocity is provided as an ArrayView, having dim vectors, one for each velocity component. Each of the vectors must either have only a single entry, if the advection velocity is constant, or have an entry for each quadrature point.
The finite element can have several components, in which case each component is advected the same way.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Divergence.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Divergence.html 2024-12-27 18:25:16.776928479 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Divergence.html 2024-12-27 18:25:16.784928534 +0000
@@ -170,7 +170,7 @@
double
factor = 1.&#href_anchor"memdoc">
Cell matrix for divergence. The derivative is on the trial function.
-
+
This is the strong divergence operator and the trial space should be at least Hdiv. The test functions may be discontinuous.
@@ -206,8 +206,8 @@
const double
factor = 1.&#href_anchor"memdoc">
The residual of the divergence operator in strong form.
-
+
This is the strong divergence operator and the trial space should be at least Hdiv. The test functions may be discontinuous.
The function cell_matrix() is the Frechet derivative of this function with respect to the test functions.
@@ -244,8 +244,8 @@
const double
factor = 1.&#href_anchor"memdoc">
The residual of the divergence operator in weak form.
-
+
This is the weak divergence operator and the test space should be at least H1. The trial functions may be discontinuous.
The trace of the divergence operator, namely the product of the jump of the normal component of the vector valued trial function and the mean value of the test function.
Weak boundary condition for the elasticity operator by Nitsche, namely on the face F the vector
-
+\]" src="form_1612.png"/>
-
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the outer normal vector and is the usual penalty parameter.
+
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the outer normal vector and is the usual penalty parameter.
Homogeneous weak boundary condition for the elasticity operator by Nitsche, namely on the face F the vector
-
+\]" src="form_1615.png"/>
-
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. is the outer normal vector and is the usual penalty parameter.
+
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. is the outer normal vector and is the usual penalty parameter.
Weak boundary condition for the Laplace operator by Nitsche, vector valued version, namely on the face F the vector
-
+\]" src="form_1618.png"/>
-
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
+
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
Weak boundary condition for the Laplace operator by Nitsche, scalar version, namely on the face F the vector
-
+\]" src="form_1634.png"/>
-
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
+
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
Weak boundary condition for the Laplace operator by Nitsche, vector valued version, namely on the face F the vector
-
+\]" src="form_1635.png"/>
-
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
+
Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. is the usual penalty parameter.
Flux for the interior penalty method for the Laplacian, namely on the face F the matrices associated with the bilinear form
-
+\]" src="form_1636.png"/>
The penalty parameter should always be the mean value of the penalties needed for stability on each side. In the case of constant coefficients, it can be computed using compute_penalty().
If factor2 is missing or negative, the factor is assumed the same on both sides. If factors differ, note that the penalty parameter has to be computed accordingly.
@@ -564,10 +564,10 @@
double
factor2 = -1.&#href_anchor"memdoc">
Flux for the interior penalty method for the Laplacian applied to the tangential components of a vector field, namely on the face F the matrices associated with the bilinear form
-
+\]" src="form_1637.png"/>
Warning
This function is still under development!
@@ -638,10 +638,10 @@
double
ext_factor = -1.&#href_anchor"memdoc">
Residual term for the symmetric interior penalty method:
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Maxwell.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Maxwell.html 2024-12-27 18:25:16.944929632 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceLocalIntegrators_1_1Maxwell.html 2024-12-27 18:25:16.952929687 +0000
@@ -133,22 +133,22 @@
Local integrators related to curl operators and their traces.
We use the following conventions for curl operators. First, in three space dimensions
-
+\]" src="form_1641.png"/>
-
In two space dimensions, the curl is obtained by extending a vector u to and a scalar p to . Computing the nonzero components, we obtain the scalar curl of a vector function and the vector curl of a scalar function. The current implementation exchanges the sign and we have:
- and a scalar p to . Computing the nonzero components, we obtain the scalar curl of a vector function and the vector curl of a scalar function. The current implementation exchanges the sign and we have:
Auxiliary function. Given the tensors of dim second derivatives, compute the curl of the curl of a vector function. The result in two and three dimensions is:
-
+\]" src="form_1645.png"/>
and
-
+\]" src="form_1646.png"/>
Note
The third tensor argument is not used in two dimensions and can for instance duplicate one of the previous.
Create a coupling sparsity pattern for non-matching, overlapping grids.
-
Given two non-matching triangulations, representing the domains and , with , and two finite element spaces and and , with , and two finite element spaces and , compute the sparsity pattern that would be necessary to assemble the matrix
where is the finite element space associated with the space_dh passed to this function (or part of it, if specified in space_comps), while is the finite element space associated with the immersed_dh passed to this function (or part of it, if specified in immersed_comps).
-
The sparsity is filled by locating the position of quadrature points (obtained by the reference quadrature quad) defined on elements of with respect to the embedding triangulation . For each overlapping cell, the entries corresponding to space_comps in space_dh and immersed_comps in immersed_dh are added to the sparsity pattern.
+
The sparsity is filled by locating the position of quadrature points (obtained by the reference quadrature quad) defined on elements of with respect to the embedding triangulation . For each overlapping cell, the entries corresponding to space_comps in space_dh and immersed_comps in immersed_dh are added to the sparsity pattern.
The space_comps and immersed_comps masks are assumed to be ordered in the same way: the first component of space_comps will couple with the first component of immersed_comps, the second with the second, and so on. If one of the two masks has more non-zero than the other, then the excess components will be ignored.
-
If the domain does not fall within , an exception will be thrown by the algorithm that computes the quadrature point locations. In particular, notice that this function only makes sens for dim1 lower or equal than dim0. A static assert guards that this is actually the case.
+
If the domain does not fall within , an exception will be thrown by the algorithm that computes the quadrature point locations. In particular, notice that this function only makes sens for dim1 lower or equal than dim0. A static assert guards that this is actually the case.
For both spaces, it is possible to specify a custom Mapping, which defaults to StaticMappingQ1 for both.
This function will also work in parallel, provided that the immersed triangulation is of type parallel::shared::Triangulation<dim1,spacedim>. An exception is thrown if you use an immersed parallel::distributed::Triangulation<dim1,spacedim>.
See the tutorial program step-60 for an example on how to use this function.
Create a coupling mass matrix for non-matching, overlapping grids.
-
Given two non-matching triangulations, representing the domains and , with , and two finite element spaces and and , with , and two finite element spaces and , compute the coupling matrix
where is the finite element space associated with the space_dh passed to this function (or part of it, if specified in space_comps), while is the finite element space associated with the immersed_dh passed to this function (or part of it, if specified in immersed_comps).
-
The corresponding sparsity patterns can be computed by calling the make_coupling_sparsity_pattern function. The elements of the matrix are computed by locating the position of quadrature points defined on elements of with respect to the embedding triangulation .
+
The corresponding sparsity patterns can be computed by calling the make_coupling_sparsity_pattern function. The elements of the matrix are computed by locating the position of quadrature points defined on elements of with respect to the embedding triangulation .
The space_comps and immersed_comps masks are assumed to be ordered in the same way: the first component of space_comps will couple with the first component of immersed_comps, the second with the second, and so on. If one of the two masks has more non-zero entries non-zero than the other, then the excess components will be ignored.
-
If the domain does not fall within , an exception will be thrown by the algorithm that computes the quadrature point locations. In particular, notice that this function only makes sense for dim1 lower or equal than dim0. A static assert guards that this is actually the case.
+
If the domain does not fall within , an exception will be thrown by the algorithm that computes the quadrature point locations. In particular, notice that this function only makes sense for dim1 lower or equal than dim0. A static assert guards that this is actually the case.
For both spaces, it is possible to specify a custom Mapping, which defaults to StaticMappingQ1 for both.
This function will also work in parallel, provided that the immersed triangulation is of type parallel::shared::Triangulation<dim1,spacedim>. An exception is thrown if you use an immersed parallel::distributed::Triangulation<dim1,spacedim>.
See the tutorial program step-60 for an example on how to use this function.
where is the finite element space associated with the dh0 passed to this function (or part of it, if specified in comps0), while is the finite element space associated with the dh1 passed to this function (or part of it, if specified in comps1), and is a function derived from CutOffFunctionBase with compact support included in a ball of radius .
+
where is the finite element space associated with the dh0 passed to this function (or part of it, if specified in comps0), while is the finite element space associated with the dh1 passed to this function (or part of it, if specified in comps1), and is a function derived from CutOffFunctionBase with compact support included in a ball of radius .
The comps0 and comps1 masks are assumed to be ordered in the same way: the first component of comps0 will couple with the first component of comps1, the second with the second, and so on. If one of the two masks has more active components than the other, then the excess components will be ignored.
For both spaces, it is possible to specify a custom Mapping, which defaults to StaticMappingQ1 for both.
This function will also work in parallel, provided that at least one of the triangulations is of type parallel::shared::Triangulation<dim1,spacedim>. An exception is thrown if both triagnulations are of type parallel::distributed::Triangulation<dim1,spacedim>.
where is the finite element space associated with the dh0 passed to this function (or part of it, if specified in comps0), while is the finite element space associated with the dh1 passed to this function (or part of it, if specified in comps1), and is a function derived from CutOffFunctionBase with compact support included in a ball of radius .
+
where is the finite element space associated with the dh0 passed to this function (or part of it, if specified in comps0), while is the finite element space associated with the dh1 passed to this function (or part of it, if specified in comps1), and is a function derived from CutOffFunctionBase with compact support included in a ball of radius .
The corresponding sparsity patterns can be computed by calling the make_coupling_sparsity_pattern() function.
The comps0 and comps1 masks are assumed to be ordered in the same way: the first component of comps0 will couple with the first component of comps1, the second with the second, and so on. If one of the two masks has more active components than the other, then the excess components will be ignored.
For both spaces, it is possible to specify a custom Mapping, which defaults to StaticMappingQ1 for both.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceNonMatching_1_1internal_1_1QuadratureGeneratorImplementation.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceNonMatching_1_1internal_1_1QuadratureGeneratorImplementation.html 2024-12-27 18:25:17.028930209 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceNonMatching_1_1internal_1_1QuadratureGeneratorImplementation.html 2024-12-27 18:25:17.032930237 +0000
@@ -292,7 +292,7 @@
-
Returns the max/min bounds on the value, taken over all the entries in the incoming vector of FunctionBounds. That is, given the incoming function bounds, , this function returns , where and .
+
Returns the max/min bounds on the value, taken over all the entries in the incoming vector of FunctionBounds. That is, given the incoming function bounds, , this function returns , where and .
Finds the best choice of height function direction, given the FunctionBounds for a number of functions . Here, "best" is meant in the sense of the implicit function theorem.
-
Let be the index set of the indefinite functions:
-
.
-
This function converts the incoming bounds to a lower bound, , on the absolute value of each component of the gradient:
-
.
-
and then returns a coordinate direction, , and a lower bound , such that
+
Finds the best choice of height function direction, given the FunctionBounds for a number of functions . Here, "best" is meant in the sense of the implicit function theorem.
+
Let be the index set of the indefinite functions:
+
.
+
This function converts the incoming bounds to a lower bound, , on the absolute value of each component of the gradient:
+
.
+
and then returns a coordinate direction, , and a lower bound , such that
-
+\]" src="form_2222.png"/>
-
This means is a coordinate direction such that all functions intersected by the zero contour (i.e. those belonging to ) fulfill
-
.
+
This means is a coordinate direction such that all functions intersected by the zero contour (i.e. those belonging to ) fulfill
+
.
Note that the estimated lower bound, , can be zero or negative. This means that no suitable height function direction exists. If all of the incoming functions are positive or negative definite the returned std::optional is non-set.
Given the incoming lower and upper bounds on the value of a function , return the minimum/maximum of and the function values at the vertices. That is, this function returns
+
Given the incoming lower and upper bounds on the value of a function , return the minimum/maximum of and the function values at the vertices. That is, this function returns
,
where , , and is a vertex.
It is assumed that the incoming function is scalar valued.
@@ -487,7 +487,7 @@
-
Return a lower bound, , on the absolute value of a function, :
+
Return a lower bound, , on the absolute value of a function, :
,
by estimating it from the incoming lower and upper bounds: .
By rewriting the lower and upper bounds as , where , (or , ), we get . Using the inverse triangle inequality gives . Thus, .
Let be such that is the interval and are the roots. In each subinterval, , distribute point according to the 1D-quadrature rule (quadrature1D). Take the tensor product with the quadrature point (point, weight) to create dim-dimensional quadrature points
+
Let be such that is the interval and are the roots. In each subinterval, , distribute point according to the 1D-quadrature rule (quadrature1D). Take the tensor product with the quadrature point (point, weight) to create dim-dimensional quadrature points
Return the coordinate direction that the box should be split in, assuming that the box should be split it half.
-
If the box is larger in one coordante direction, this direction is returned. If the box have the same extent in all directions, we choose the coordinate direction which is closest to being a height-function direction. That is, the direction that has a least negative estimate of . As a last resort, we choose the direction 0, if height_direction_data non-set.
+
If the box is larger in one coordante direction, this direction is returned. If the box have the same extent in all directions, we choose the coordinate direction which is closest to being a height-function direction. That is, the direction that has a least negative estimate of . As a last resort, we choose the direction 0, if height_direction_data non-set.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceOpenCASCADE.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceOpenCASCADE.html 2024-12-27 18:25:17.068930484 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceOpenCASCADE.html 2024-12-27 18:25:17.076930539 +0000
@@ -432,7 +432,7 @@
-
Perform the intersection of the given topological shape with the plane . The returned topological shape will contain as few bsplines as possible. An exception is thrown if the intersection produces an empty shape.
+
Perform the intersection of the given topological shape with the plane . The returned topological shape will contain as few bsplines as possible. An exception is thrown if the intersection produces an empty shape.
Given a Triangulation and an optional Mapping, create a vector of smooth curves that interpolate the connected parts of the boundary vertices of the Triangulation and return them as a vector of TopoDS_Edge objects.
-
This function constructs closed Bspline curve objects passing through all vertices of the boundary of the triangulation, with Continuity on each vertex except the first, where only continuity is guaranteed.
+
This function constructs closed Bspline curve objects passing through all vertices of the boundary of the triangulation, with Continuity on each vertex except the first, where only continuity is guaranteed.
The returned curves are ordered with respect to the indices of the faces that make up the triangulation boundary, i.e., the first curve is the one extracted starting from the face with the lowest index, and so on.
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceParticles_1_1Utilities.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceParticles_1_1Utilities.html 2024-12-27 18:25:17.096930676 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceParticles_1_1Utilities.html 2024-12-27 18:25:17.100930704 +0000
@@ -154,21 +154,21 @@
Create an interpolation sparsity pattern for particles.
-
Given a triangulation representing the domain , a particle handler of particles in , and a scalar finite element space , compute the sparsity pattern that would be necessary to assemble the matrix
-, a particle handler of particles in , and a scalar finite element space , compute the sparsity pattern that would be necessary to assemble the matrix
+
+\]" src="form_2514.png"/>
where is the finite element space associated with the space_dh, and the index i is given by the particle id whose position is x_i.
In the case of vector valued finite element spaces, the components on which interpolation must be performed can be selected using a component mask. Only primitive finite element spaces are supported.
When selecting more than one component, the resulting sparsity will have dimension equal to particle_handler.n_global_particles() * mask.n_selected_components() times space_dh.n_dofs(), and the corresponding matrix entries are given by
-
+\]" src="form_2515.png"/>
-
where comp_j is the only non zero component of the vector valued basis function v_j (equal to fe.system_to_component_index(j).first), k corresponds to its index within the selected components of the mask, and is the unit vector in the direction comp_j.
-
The sparsity is filled by locating the position of the particle with index i within the particle handler with respect to the embedding triangulation , and coupling it with all the local degrees of freedom specified in the component mask space_comps, following the ordering in which they are selected in the mask space_comps.
-
If a particle does not fall within , it is ignored, and the corresponding rows of the sparsity will be empty.
+
where comp_j is the only non zero component of the vector valued basis function v_j (equal to fe.system_to_component_index(j).first), k corresponds to its index within the selected components of the mask, and is the unit vector in the direction comp_j.
+
The sparsity is filled by locating the position of the particle with index i within the particle handler with respect to the embedding triangulation , and coupling it with all the local degrees of freedom specified in the component mask space_comps, following the ordering in which they are selected in the mask space_comps.
+
If a particle does not fall within , it is ignored, and the corresponding rows of the sparsity will be empty.
Given a triangulation representing the domains , a particle handler of particles in , and a scalar finite element space , compute the matrix
-, a particle handler of particles in , and a scalar finite element space , compute the matrix
+
+\]" src="form_2517.png"/>
where is the finite element space associated with the space_dh, and the index i is given by the particle id whose position is x_i.
In the case of vector valued finite element spaces, the components on which interpolation must be performed can be selected using a component mask. Only primitive finite element spaces are supported.
When selecting more than one component, the resulting sparsity will have dimension equal to particle_handler.n_global_particles() * mask.n_selected_components() times space_dh.n_dofs(), and the corresponding matrix entries are given by
-
+\]" src="form_2515.png"/>
-
where comp_j is the only non zero component of the vector valued basis function v_j (equal to fe.system_to_component_index(j).first), k corresponds to its index within the selected components of the mask, and is the unit vector in the direction comp_j.
-
The matrix is filled by locating the position of the particle with index i within the particle handler with respect to the embedding triangulation , and coupling it with all the local degrees of freedom specified in the component mask space_comps, following the ordering in which they are selected in the mask space_comps.
-
If a particle does not fall within , it is ignored, and the corresponding rows of the matrix will be zero.
+
where comp_j is the only non zero component of the vector valued basis function v_j (equal to fe.system_to_component_index(j).first), k corresponds to its index within the selected components of the mask, and is the unit vector in the direction comp_j.
+
The matrix is filled by locating the position of the particle with index i within the particle handler with respect to the embedding triangulation , and coupling it with all the local degrees of freedom specified in the component mask space_comps, following the ordering in which they are selected in the mask space_comps.
+
If a particle does not fall within , it is ignored, and the corresponding rows of the matrix will be zero.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Notation_1_1Kelvin.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Notation_1_1Kelvin.html 2024-12-27 18:25:17.144931006 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Notation_1_1Kelvin.html 2024-12-27 18:25:17.152931061 +0000
@@ -196,7 +196,7 @@
\end{array} \right] ,
\]" src="form_2555.png"/>
-
where denotes the Kelvin index for the tensor component, while for a general rank-2 tensor
+
where denotes the Kelvin index for the tensor component, while for a general rank-2 tensor
&#href_anchor"details" id="details">
Detailed Description
A collection of operations to assist in the transformation of tensor quantities from the reference to spatial configuration, and vice versa. These types of transformation are typically used to re-express quantities measured or computed in one configuration in terms of a second configuration.
We will use the same notation for the coordinates , transformations , differential operator and deformation gradient as discussed for namespace Physics::Elasticity.
+
We will use the same notation for the coordinates , transformations , differential operator and deformation gradient as discussed for namespace Physics::Elasticity.
As a further point on notation, we will follow Holzapfel (2007) and denote the push forward transformation as and the pull back transformation as . We will also use the annotation to indicate that a tensor is a contravariant tensor, and that it is covariant. In other words, these indices do not actually change the tensor, they just indicate the kind of object a particular tensor is.
Note
For these transformations, unless otherwise stated, we will strictly assume that all indices of the transformed tensors derive from one coordinate system; that is to say that they are not multi-point tensors (such as the Piola stress in elasticity).
Function Documentation
@@ -205,8 +205,8 @@
Parameters
-
[in]
V
The vector to be transformed
-
[in]
B
The transformation matrix
+
[in]
V
The vector to be transformed
+
[in]
B
The transformation matrix
@@ -240,7 +240,7 @@
Parameters
[in]
T
The tensor to be transformed
-
[in]
B
The transformation matrix
+
[in]
B
The transformation matrix
@@ -274,7 +274,7 @@
Parameters
[in]
T
The tensor to be transformed
-
[in]
B
The transformation matrix
+
[in]
B
The transformation matrix
@@ -307,7 +307,7 @@
Parameters
[in]
H
The tensor to be transformed
-
[in]
B
The transformation matrix
+
[in]
B
The transformation matrix
@@ -340,7 +340,7 @@
Parameters
[in]
H
The tensor to be transformed
-
[in]
B
The transformation matrix
+
[in]
B
The transformation matrix
/usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Transformations_1_1Contravariant.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Transformations_1_1Contravariant.html 2024-12-27 18:25:17.204931418 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespacePhysics_1_1Transformations_1_1Contravariant.html 2024-12-27 18:25:17.212931473 +0000
@@ -484,11 +484,11 @@
Calculate the angle between two vectors a and b, where both vectors are located in a plane described by a normal vector axis.
-
The angle computed by this function corresponds to the rotation angle that would transform the vector a into the vector b around the vector axis. Thus, contrary to the function above, we get a signed angle which will be in the range .
+
The angle computed by this function corresponds to the rotation angle that would transform the vector a into the vector b around the vector axis. Thus, contrary to the function above, we get a signed angle which will be in the range .
The vector axis needs to be a unit vector and be perpendicular to both vectors a and b.
This function uses the geometric definitions of both the scalar and cross product.
-
+\end{align*}" src="form_2642.png"/>
We can create the tangent of the angle using both products.
-
+\]" src="form_2643.png"/>
Note
Only applicable for three-dimensional vectors spacedim == 3.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSLEPcWrappers.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSLEPcWrappers.html 2024-12-27 18:25:17.316932187 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSLEPcWrappers.html 2024-12-27 18:25:17.320932214 +0000
@@ -123,13 +123,13 @@
Base namespace for solver classes using the SLEPc solvers which are selected based on flags passed to the eigenvalue problem solver context. Derived classes set the right flags to set the right solver.
-
The SLEPc solvers are intended to be used for solving the generalized eigenspectrum problem , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively. The emphasis is on methods and techniques appropriate for problems in which the associated matrices are sparse. Most of the methods offered by the SLEPc library are projection methods or other methods with similar properties; and wrappers are provided to interface to SLEPc solvers that handle both of these problem sets.
+
The SLEPc solvers are intended to be used for solving the generalized eigenspectrum problem , for ; where is a system matrix, is a mass matrix, and are a set of eigenvalues and eigenvectors respectively. The emphasis is on methods and techniques appropriate for problems in which the associated matrices are sparse. Most of the methods offered by the SLEPc library are projection methods or other methods with similar properties; and wrappers are provided to interface to SLEPc solvers that handle both of these problem sets.
SLEPcWrappers can be implemented in application codes in the following way:
for the generalized eigenvalue problem , where the variable const unsigned int size_of_spectrum tells SLEPc the number of eigenvector/eigenvalue pairs to solve for. Additional options and solver parameters can be passed to the SLEPc solvers before calling solve(). For example, if the matrices of the general eigenspectrum problem are not hermitian and the lower eigenvalues are wanted only, the following code can be implemented before calling solve():
system.set_problem_type (EPS_NHEP);
+
for the generalized eigenvalue problem , where the variable const unsigned int size_of_spectrum tells SLEPc the number of eigenvector/eigenvalue pairs to solve for. Additional options and solver parameters can be passed to the SLEPc solvers before calling solve(). For example, if the matrices of the general eigenspectrum problem are not hermitian and the lower eigenvalues are wanted only, the following code can be implemented before calling solve():
system.set_problem_type (EPS_NHEP);
system.set_which_eigenpairs (EPS_SMALLEST_REAL);
These options can also be set at the command line.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSUNDIALS.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSUNDIALS.html 2024-12-27 18:25:17.340932352 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSUNDIALS.html 2024-12-27 18:25:17.344932379 +0000
@@ -192,7 +192,7 @@
const VectorType &b,
double tol)>
Type of function objects to interface with SUNDIALS' linear solvers
-
This function type encapsulates the action of solving . The LinearOperatorop encapsulates the matrix vector product and the LinearOperatorprec encapsulates the application of the preconditioner . The user can specify function objects of this type to attach custom linear solver routines to SUNDIALS. The two LinearOperators op and prec are built internally by SUNDIALS based on user settings. The parameters are interpreted as follows:
+
This function type encapsulates the action of solving . The LinearOperatorop encapsulates the matrix vector product and the LinearOperatorprec encapsulates the application of the preconditioner . The user can specify function objects of this type to attach custom linear solver routines to SUNDIALS. The two LinearOperators op and prec are built internally by SUNDIALS based on user settings. The parameters are interpreted as follows:
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Fourier.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Fourier.html 2024-12-27 18:25:17.372932571 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Fourier.html 2024-12-27 18:25:17.376932599 +0000
@@ -122,19 +122,19 @@
Detailed Description
Smoothness estimation strategy based on the decay of Fourier expansion coefficients.
-
From the definition, we can write our Fourier series expansion of the finite element solution on cell with polynomial degree as a matrix product
-Fourier series expansion of the finite element solution on cell with polynomial degree as a matrix product
+
+\end{eqnarray*}" src="form_2315.png"/>
-
with the degrees of freedom and the corresponding shape functions. are exponential functions on cell . and are coefficients and transformation matrices from the Fourier expansion of each shape function. For practical reasons, we will perform the calculation of these matrices and coefficients only on the reference cell . We only have to calculate the transformation matrices once this way. However, results are only applicable if mapping from the reference cell to the actual cell is linear. We use the class FESeries::Fourier to determine all coefficients .
-
If the finite element approximation on cell is part of the Hilbert space , then the following integral must exist for both the finite element and spectral representation of our solution
- the degrees of freedom and the corresponding shape functions. are exponential functions on cell . and are coefficients and transformation matrices from the Fourier expansion of each shape function. For practical reasons, we will perform the calculation of these matrices and coefficients only on the reference cell . We only have to calculate the transformation matrices once this way. However, results are only applicable if mapping from the reference cell to the actual cell is linear. We use the class FESeries::Fourier to determine all coefficients .
+
If the finite element approximation on cell is part of the Hilbert space , then the following integral must exist for both the finite element and spectral representation of our solution
+
+\end{eqnarray*}" src="form_2319.png"/>
The sum is finite only if the summands decay at least with order
-
+\]" src="form_2320.png"/>
-
for all . The additional factor stems from the fact that, since we sum over all multi-indices that are located on a dim-dimensional sphere, we actually have, up to a constant, modes located in each increment that need to be taken into account. By a comparison of exponents, we can rewrite this condition as
-. The additional factor stems from the fact that, since we sum over all multi-indices that are located on a dim-dimensional sphere, we actually have, up to a constant, modes located in each increment that need to be taken into account. By a comparison of exponents, we can rewrite this condition as
+
+\]" src="form_2325.png"/>
-
The next step is to estimate how fast these coefficients decay with . Thus, we perform a least-squares fit
-. Thus, we perform a least-squares fit
+
+\]" src="form_2327.png"/>
-
with regression coefficients and . For simplification, we apply a logarithm on our minimization problem
- and . For simplification, we apply a logarithm on our minimization problem
+
+\]" src="form_2328.png"/>
-
where . This is now a problem for which the optimality conditions , are linear in . We can write these conditions as follows:
-. This is now a problem for which the optimality conditions , are linear in . We can write these conditions as follows:
While we are not particularly interested in the actual value of , the formula above gives us a means to calculate the value of the exponent that we can then use to determine that is in with . The decay rates will suffice as our smoothness indicators and will be calculated on each cell for any provided solution.
While we are not particularly interested in the actual value of , the formula above gives us a means to calculate the value of the exponent that we can then use to determine that is in with . The decay rates will suffice as our smoothness indicators and will be calculated on each cell for any provided solution.
Note
An extensive demonstration of the use of these functions is provided in step-27.
In this variant of the estimation strategy for higher dimensions, we will consider all mode vectors describing Fourier polynomials and perform one least-squares fit over all coefficients at once. If there are multiple coefficients corresponding to the same absolute value of modes , we take the maximum among those. Thus, the least-squares fit is performed on
- describing Fourier polynomials and perform one least-squares fit over all coefficients at once. If there are multiple coefficients corresponding to the same absolute value of modes , we take the maximum among those. Thus, the least-squares fit is performed on
+
+\]" src="form_2346.png"/>
-
for and , with the polynomial degree of the finite element. We exclude the modes to avoid the singularity of the logarithm.
-
The regression_strategy parameter determines which norm will be used on the subset of coefficients with the same absolute value . Default is VectorTools::Linfty_norm for a maximum approximation.
-
For a provided solution vector solution defined on a DoFHandlerdof_handler, this function returns a vector smoothness_indicators with as many elements as there are cells where each element contains the estimated regularity .
+
for and , with the polynomial degree of the finite element. We exclude the modes to avoid the singularity of the logarithm.
+
The regression_strategy parameter determines which norm will be used on the subset of coefficients with the same absolute value . Default is VectorTools::Linfty_norm for a maximum approximation.
+
For a provided solution vector solution defined on a DoFHandlerdof_handler, this function returns a vector smoothness_indicators with as many elements as there are cells where each element contains the estimated regularity .
A series expansion object fe_fourier has to be supplied, which needs to be constructed with the same FECollection object as the dof_handler.
-
The parameter smallest_abs_coefficient allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
+
The parameter smallest_abs_coefficient allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
Smoothness indicators are usually used to decide whether to perform h- or p-adaptation. So in most cases, we only need to calculate those indicators on cells flagged for refinement or coarsening. The parameter only_flagged_cells controls whether this particular subset or all cells will be considered. By default, all cells will be considered. When only flagged cells are supposed to be considered, smoothness indicators will only be set on those vector entries of flagged cells; the others will be set to a signaling NaN.
In this variant of the estimation strategy for higher dimensions, we only consider modes in each coordinate direction, i.e., only mode vectors with one nonzero entry. We perform the least-squares fit in each coordinate direction separately and take the lowest decay rate among them.
-
The coefficients_predicate parameter selects Fourier coefficients , for linear regression in each coordinate direction. The user is responsible for updating the vector of flags provided to this function. Note that its size is , where is the polynomial degree of the FE basis on a given element. The default implementation will use all Fourier coefficients in each coordinate direction, i.e., set all the elements of the vector to true.
-
For a provided solution vector solution defined on a DoFHandlerdof_handler, this function returns a vector smoothness_indicators with as many elements as there are cells where each element contains the estimated regularity .
+
In this variant of the estimation strategy for higher dimensions, we only consider modes in each coordinate direction, i.e., only mode vectors with one nonzero entry. We perform the least-squares fit in each coordinate direction separately and take the lowest decay rate among them.
+
The coefficients_predicate parameter selects Fourier coefficients , for linear regression in each coordinate direction. The user is responsible for updating the vector of flags provided to this function. Note that its size is , where is the polynomial degree of the FE basis on a given element. The default implementation will use all Fourier coefficients in each coordinate direction, i.e., set all the elements of the vector to true.
+
For a provided solution vector solution defined on a DoFHandlerdof_handler, this function returns a vector smoothness_indicators with as many elements as there are cells where each element contains the estimated regularity .
A series expansion object fe_fourier has to be supplied, which needs to be constructed with the same FECollection object as the dof_handler.
-
The parameter smallest_abs_coefficient allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are fewer than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
+
The parameter smallest_abs_coefficient allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are fewer than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
Smoothness indicators are usually used to decide whether to perform h- or p-adaptation. So in most cases, we only need to calculate those indicators on cells flagged for refinement or coarsening. The parameter only_flagged_cells controls whether this particular subset or all cells will be considered. By default, all cells will be considered. When only flagged cells are supposed to be considered, smoothness indicators will only be set on those vector entries of flagged cells; the others will be set to a signaling NaN.
Returns a FESeries::Fourier object for Fourier series expansions with the default configuration for smoothness estimation purposes.
-
For each finite element of the provided fe_collection, we use as many modes as its polynomial degree plus two. Further for each element, we use a 5-point Gaussian quarature iterated in each dimension by the maximal wave number, which is the number of modes decreased by one since we start with .
+
For each finite element of the provided fe_collection, we use as many modes as its polynomial degree plus two. Further for each element, we use a 5-point Gaussian quarature iterated in each dimension by the maximal wave number, which is the number of modes decreased by one since we start with .
As the Fourier expansion can only be performed on scalar fields, this class does not operate on vector-valued finite elements and will therefore throw an assertion. However, each component of a finite element field can be treated as a scalar field, respectively, on which Fourier expansions are again possible. For this purpose, the optional parameter component defines which component of each FiniteElement will be used. The default value of component only applies to scalar FEs, in which case it indicates that the sole component is to be decomposed. For vector-valued FEs, a non-default value must be explicitly provided.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Legendre.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Legendre.html 2024-12-27 18:25:17.404932791 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSmoothnessEstimator_1_1Legendre.html 2024-12-27 18:25:17.404932791 +0000
@@ -122,25 +122,25 @@
Detailed Description
Smoothness estimation strategy based on the decay of Legendre expansion coefficients.
-
In one dimension, the finite element solution on cell with polynomial degree can be written as
- with polynomial degree can be written as
+
+\end{eqnarray*}" src="form_2305.png"/>
-
where are degrees of freedom and are the corresponding shape functions. are Legendre polynomials on cell . and are coefficients and transformation matrices from the Legendre expansion of each shape function. For practical reasons, we will perform the calculation of these matrices and coefficients only on the reference cell . We only have to calculate the transformation matrices once this way. However, results are only applicable if the mapping from the reference cell to the actual cell is affine. We use the class FESeries::Legendre to determine all coefficients .
+
where are degrees of freedom and are the corresponding shape functions. are Legendre polynomials on cell . and are coefficients and transformation matrices from the Legendre expansion of each shape function. For practical reasons, we will perform the calculation of these matrices and coefficients only on the reference cell . We only have to calculate the transformation matrices once this way. However, results are only applicable if the mapping from the reference cell to the actual cell is affine. We use the class FESeries::Legendre to determine all coefficients .
A function is analytic, i.e., representable by a power series, if and only if their Legendre expansion coefficients decay as (see [eibner2007hp])
-
+\]" src="form_2309.png"/>
-
We determine their decay rate by performing the linear regression fit of
- by performing the linear regression fit of
+
+\]" src="form_2311.png"/>
-
for , with the polynomial degree of the finite element. The rate of the decay can be used to estimate the smoothness. For example, one strategy to implement hp-refinement criteria is to perform p-refinement if (see [mavriplis1994hp]).
+
for , with the polynomial degree of the finite element. The rate of the decay can be used to estimate the smoothness. For example, one strategy to implement hp-refinement criteria is to perform p-refinement if (see [mavriplis1994hp]).
In this variant of the estimation strategy for higher dimensions, we will consider all mode vectors describing Legendre polynomials and perform one least-squares fit over all coefficients at once. If there are multiple coefficients corresponding to the same absolute value of modes , we take the maximum among those. Thus, the least-squares fit is performed on
- describing Legendre polynomials and perform one least-squares fit over all coefficients at once. If there are multiple coefficients corresponding to the same absolute value of modes , we take the maximum among those. Thus, the least-squares fit is performed on
+
+\end{eqnarray*}" src="form_2338.png"/>
-
for and , with the polynomial degree of the finite element.
+
for and , with the polynomial degree of the finite element.
For a finite element approximation solution, this function writes the decay rate for every cell into the output vector smoothness_indicators.
Parameters
-
[in]
fe_legendre
FESeries::Legendre object to calculate coefficients. This object needs to be initialized to have at least coefficients in each direction for every finite element in the collection, where is its polynomial degree.
+
[in]
fe_legendre
FESeries::Legendre object to calculate coefficients. This object needs to be initialized to have at least coefficients in each direction for every finite element in the collection, where is its polynomial degree.
Determines which norm will be used on the subset of coefficients with the same absolute value . Default is VectorTools::Linfty_norm for a maximum approximation.
-
[in]
smallest_abs_coefficient
The smallest absolute value of the coefficient to be used in linear regression. Note that Legendre coefficients of some functions may have a repeating pattern of zero coefficients (i.e. for functions that are locally symmetric or antisymmetric about the midpoint of the element in any coordinate direction). Thus this parameters allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients, the returned value for this cell will be .
+
[in]
regression_strategy
Determines which norm will be used on the subset of coefficients with the same absolute value . Default is VectorTools::Linfty_norm for a maximum approximation.
+
[in]
smallest_abs_coefficient
The smallest absolute value of the coefficient to be used in linear regression. Note that Legendre coefficients of some functions may have a repeating pattern of zero coefficients (i.e. for functions that are locally symmetric or antisymmetric about the midpoint of the element in any coordinate direction). Thus this parameters allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients, the returned value for this cell will be .
[in]
only_flagged_cells
Smoothness indicators are usually used to decide whether to perform h- or p-adaptation. So in most cases, we only need to calculate those indicators on cells flagged for refinement or coarsening. This parameter controls whether this particular subset or all cells will be considered. By default, all cells will be considered. When only flagged cells are supposed to be considered, smoothness indicators will only be set on those vector entries of flagged cells; the others will be set to a signaling NaN.
In this variant of the estimation strategy for higher dimensions, we only consider modes in each coordinate direction, i.e., only mode vectors with one nonzero entry. We perform the least-squares fit in each coordinate direction separately and take the lowest decay rate among them.
+
In this variant of the estimation strategy for higher dimensions, we only consider modes in each coordinate direction, i.e., only mode vectors with one nonzero entry. We perform the least-squares fit in each coordinate direction separately and take the lowest decay rate among them.
For a finite element approximation solution, this function writes the decay rate for every cell into the output vector smoothness_indicators.
Parameters
-
[in]
fe_legendre
FESeries::Legendre object to calculate coefficients. This object needs to be initialized to have at least coefficients in each direction, where is the maximum polynomial degree to be used.
+
[in]
fe_legendre
FESeries::Legendre object to calculate coefficients. This object needs to be initialized to have at least coefficients in each direction, where is the maximum polynomial degree to be used.
A predicate to select Legendre coefficients , for linear regression in each coordinate direction. The user is responsible for updating the vector of flags provided to this function. Note that its size is , where is the polynomial degree of the FE basis on a given element. The default implementation will use all Legendre coefficients in each coordinate direction, i.e. set all elements of the vector to true.
-
[in]
smallest_abs_coefficient
The smallest absolute value of the coefficient to be used in linear regression in each coordinate direction. Note that Legendre coefficients of some functions may have a repeating pattern of zero coefficients (i.e. for functions that are locally symmetric or antisymmetric about the midpoint of the element in any coordinate direction). Thus this parameters allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
+
[in]
coefficients_predicate
A predicate to select Legendre coefficients , for linear regression in each coordinate direction. The user is responsible for updating the vector of flags provided to this function. Note that its size is , where is the polynomial degree of the FE basis on a given element. The default implementation will use all Legendre coefficients in each coordinate direction, i.e. set all elements of the vector to true.
+
[in]
smallest_abs_coefficient
The smallest absolute value of the coefficient to be used in linear regression in each coordinate direction. Note that Legendre coefficients of some functions may have a repeating pattern of zero coefficients (i.e. for functions that are locally symmetric or antisymmetric about the midpoint of the element in any coordinate direction). Thus this parameters allows to ignore small (in absolute value) coefficients within the linear regression fit. In case there are less than two nonzero coefficients for a coordinate direction, this direction will be skipped. If all coefficients are zero, the returned value for this cell will be .
[in]
only_flagged_cells
Smoothness indicators are usually used to decide whether to perform h- or p-adaptation. So in most cases, we only need to calculate those indicators on cells flagged for refinement or coarsening. This parameter controls whether this particular subset or all cells will be considered. By default, all cells will be considered. When only flagged cells are supposed to be considered, smoothness indicators will only be set on those vector entries of flagged cells; the others will be set to NaN.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSparseMatrixTools.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSparseMatrixTools.html 2024-12-27 18:25:17.424932928 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceSparseMatrixTools.html 2024-12-27 18:25:17.428932956 +0000
@@ -152,18 +152,18 @@
SparsityPatternType2 &
sparsity_pattern_out&#href_anchor"memdoc">
Given a sparse matrix (system_matrix, sparsity_pattern), construct a new sparse matrix (system_matrix_out, sparsity_pattern_out) by restriction
-
+\]" src="form_2014.png"/>
-
where the Boolean matrix is defined by the entries of requested_is.
-
The function can be called by multiple processes with different sets of indices, allowing to assign each process a different .
+
where the Boolean matrix is defined by the entries of requested_is.
+
The function can be called by multiple processes with different sets of indices, allowing to assign each process a different .
Such a function is useful to implement Schwarz methods, where operations of type
-
+\]" src="form_2016.png"/>
-
are performed to iteratively solve a system of type .
+
are performed to iteratively solve a system of type .
Warning
This is a collective call that needs to be executed by all processes in the communicator of sparse_matrix_in.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceTensorAccessors.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceTensorAccessors.html 2024-12-27 18:25:17.456933148 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceTensorAccessors.html 2024-12-27 18:25:17.456933148 +0000
@@ -191,7 +191,7 @@
Note
This function returns an internal class object consisting of an array subscript operator operator[](unsigned int) and an alias value_type describing its return value.
Template Parameters
-
index
The index to be shifted to the end. Indices are counted from 0, thus the valid range is .
+
index
The index to be shifted to the end. Indices are counted from 0, thus the valid range is .
rank
Rank of the tensorial object t
T
A tensorial object of rank rank. T must provide a local alias value_type and an index operator operator[]() that returns a (const or non-const) reference of value_type.
@@ -275,12 +275,12 @@
This function contracts two tensorial objects left and right and stores the result in result. The contraction is done over the lastno_contr indices of both tensorial objects:
-
+\]" src="form_900.png"/>
Calling this function is equivalent of writing the following low level code:
for(unsignedint i_0 = 0; i_0 < dim; ++i_0)
...
@@ -335,12 +335,12 @@
Full contraction of three tensorial objects:
-
+\]" src="form_901.png"/>
Calling this function is equivalent of writing the following low level code:
T1 result = T1();
for(unsignedint i_0 = 0; i_0 < dim; ++i_0)
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities.html 2024-12-27 18:25:17.508933505 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities.html 2024-12-27 18:25:17.512933533 +0000
@@ -1034,13 +1034,13 @@
Calculate a fixed power, provided as a template argument, of a number.
-
This function provides an efficient way to calculate things like where N is a known number at compile time. The function computes the power of via the "recursive doubling" approach in which, for example, is computed as
+
This function provides an efficient way to calculate things like where N is a known number at compile time. The function computes the power of via the "recursive doubling" approach in which, for example, is computed as
where computing requires one product, computing is achieved by multiplying the previously computed by itself (requiring another multiplication), and then the product is computed via two more multiplications for a total of 4 multiplications instead of the naively necessary 6.
-
The major savings this function generates result, however, from the fact that it exploits that we have an integer power of the argument . The alternative to computing such powers, std::pow(t,7) uses the std::pow function that takes the exponent as a floating point number and, because it has to cater to the complexities of the general situation, is vastly slower.
+
The major savings this function generates result, however, from the fact that it exploits that we have an integer power of the argument . The alternative to computing such powers, std::pow(t,7) uses the std::pow function that takes the exponent as a floating point number and, because it has to cater to the complexities of the general situation, is vastly slower.
Use this function as in fixed_power<dim> (t) or fixed_power<7> (t).
Apply Chebyshev polynomial of the operator H to x. For a non-defective operator with a complete set of eigenpairs , the action of a polynomial filter is given by , where . Thus by appropriately choosing the polynomial filter, one can alter the eigenmodes contained in .
+
Apply Chebyshev polynomial of the operator H to x. For a non-defective operator with a complete set of eigenpairs , the action of a polynomial filter is given by , where . Thus by appropriately choosing the polynomial filter, one can alter the eigenmodes contained in .
This function uses Chebyshev polynomials of first kind. Below is an example of polynomial of degree normalized to unity at .
@@ -298,8 +298,8 @@
-
By introducing a linear mapping from unwanted_spectrum to , we can dump the corresponding modes in x. The higher the polynomial degree , the more rapid it grows outside of the . In order to avoid numerical overflow, we normalize polynomial filter to unity at tau. Thus, the filtered operator is .
-
The action of the Chebyshev filter only requires evaluation of vmult() of H and is based on the recursion equation for Chebyshev polynomial of degree : with and .
+
By introducing a linear mapping from unwanted_spectrum to , we can dump the corresponding modes in x. The higher the polynomial degree , the more rapid it grows outside of the . In order to avoid numerical overflow, we normalize polynomial filter to unity at tau. Thus, the filtered operator is .
+
The action of the Chebyshev filter only requires evaluation of vmult() of H and is based on the recursion equation for Chebyshev polynomial of degree : with and .
vector_memory is used to allocate memory for temporary objects.
This function implements the algorithm (with a minor fix of sign of ) from [Zhou2014].
Note
If tau is equal to std::numeric_limits<double>::infinity(), no normalization will be performed.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI.html 2024-12-27 18:25:17.596934109 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI.html 2024-12-27 18:25:17.596934109 +0000
@@ -1313,7 +1313,7 @@
For each process on a communicator with processes, compute both the (exclusive) partial sum and the total sum , and return these two values as a pair. The former is computed via the MPI_Exscan function where the partial sum is typically called "(exclusive) scan" of the values provided by the individual processes. The term "prefix sum" is also used.
+
For each process on a communicator with processes, compute both the (exclusive) partial sum and the total sum , and return these two values as a pair. The former is computed via the MPI_Exscan function where the partial sum is typically called "(exclusive) scan" of the values provided by the individual processes. The term "prefix sum" is also used.
This function is only available if T is a type natively supported by MPI.
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI_1_1ConsensusAlgorithms.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI_1_1ConsensusAlgorithms.html 2024-12-27 18:25:17.632934357 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceUtilities_1_1MPI_1_1ConsensusAlgorithms.html 2024-12-27 18:25:17.636934384 +0000
@@ -140,7 +140,7 @@
A namespace for algorithms that implement the task of communicating in a dynamic-sparse way. In computer science, this is often called a consensus problem.
-
The problem consensus algorithms are trying to solve is this: Let's say you have processes that work together via MPI. Each (or at least some) of these want to send information to some of the other processes, or request information from other processes. No process knows which other process wants to communicate with them. The challenge is to determine who needs to talk to whom and what information needs to be sent, and to come up with an algorithm that ensures that this communication happens.
+
The problem consensus algorithms are trying to solve is this: Let's say you have processes that work together via MPI. Each (or at least some) of these want to send information to some of the other processes, or request information from other processes. No process knows which other process wants to communicate with them. The challenge is to determine who needs to talk to whom and what information needs to be sent, and to come up with an algorithm that ensures that this communication happens.
That this is not a trivial problem can be seen by an analogy of the postal service. There, some senders may request information from some other participants in the postal service. So they send a letter that requests the information, but the recipients do not know how many such letters they need to expect (or that they should expect any at all). They also do not know how long they need to keep checking their mailbox for incoming requests. The recipients can be considered reliable, however: We can assume that everyone who is sent a request puts a letter with the answer in the mail. This time at least the recipients of these answers know that they are waiting for these answers because they have previously sent a request. They do not know in advance, however, when the answer will arrive and how long to wait. The goal of a consensus algorithm is then to come up with a strategy in which every participant can say who they want to send requests to, what that request is, and is then guaranteed an answer. The algorithm will only return when all requests by all participants have been answered and the answer delivered to the requesters.
The problem is generally posed in terms of requests and answers. In practice, either of these two may be empty messages. For example, processes may simply want to send information to others that they know these others need; in this case, the "answer" message may be empty and its meaning is simply an affirmation that the information was received. Similarly, in some cases processes simply need to inform others that they want information, but the destination process knows what information is being requested (based on where in the program the request happens) and can send that information without there be any identifying information in the request; in that case, the request message may be empty and simply serve to identify the requester. (Each message can be queried for its sender.)
As mentioned in the first paragraph, the algorithms we are interested in are "dynamic-sparse":
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceVectorTools.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceVectorTools.html 2024-12-27 18:25:17.756935208 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceVectorTools.html 2024-12-27 18:25:17.760935235 +0000
@@ -343,7 +343,7 @@
-
Projection: compute the L2-projection of the given function onto the finite element space, i.e. if f is the function to be projected, compute fh in Vh such that (fh,vh)=(f,vh) for all discrete test functions vh. This is done through the solution of the linear system of equations M v = f where M is the mass matrix and . The solution vector then is the nodal representation of the projection fh. The project() functions are used in the step-21 and step-23 tutorial programs.
+
Projection: compute the L2-projection of the given function onto the finite element space, i.e. if f is the function to be projected, compute fh in Vh such that (fh,vh)=(f,vh) for all discrete test functions vh. This is done through the solution of the linear system of equations M v = f where M is the mass matrix and . The solution vector then is the nodal representation of the projection fh. The project() functions are used in the step-21 and step-23 tutorial programs.
In order to get proper results, it be may necessary to treat boundary conditions right. Below are listed some cases where this may be needed. If needed, this is done by L2-projection of the trace of the given function onto the finite element space restricted to the boundary of the domain, then taking this information and using it to eliminate the boundary nodes from the mass matrix of the whole domain, using the MatrixTools::apply_boundary_values() function. The projection of the trace of the function to the boundary is done with the VectorTools::project_boundary_values() (see below) function, which is called with a map of boundary functions std::map<types::boundary_id, const Function<spacedim,number>*> in which all boundary indicators from zero to numbers::internal_face_boundary_id-1 (numbers::internal_face_boundary_id is used for other purposes, see the Triangulation class documentation) point to the function to be projected. The projection to the boundary takes place using a second quadrature formula on the boundary given to the project() function. The first quadrature formula is used to compute the right hand side and for numerical quadrature of the mass matrix.
The projection of the boundary values first, then eliminating them from the global system of equations is not needed usually. It may be necessary if you want to enforce special restrictions on the boundary values of the projected function, for example in time dependent problems: you may want to project the initial values but need consistency with the boundary values for later times. Since the latter are projected onto the boundary in each time step, it is necessary that we also project the boundary values of the initial values, before projecting them to the whole domain.
Obviously, the results of the two schemes for projection are different. Usually, when projecting to the boundary first, the L2-norm of the difference between original function and projection over the whole domain will be larger (factors of five have been observed) while the L2-norm of the error integrated over the boundary should of course be less. The reverse should also hold if no projection to the boundary is performed.
@@ -406,220 +406,220 @@
-
Denote which norm/integral is to be computed by the integrate_difference() function on each cell and compute_global_error() for the whole domain. Let be a finite element function with components where component is denoted by and be the reference function (the fe_function and exact_solution arguments to integrate_difference()). Let be the difference or error between the two. Further, let be the weight function of integrate_difference(), which is assumed to be equal to one if not supplied. Finally, let be the exponent argument (for -norms).
-
In the following,we denote by the local error computed by integrate_difference() on cell , whereas is the global error computed by compute_global_error(). Note that integrals are approximated by quadrature in the usual way:
-integrate_difference() function on each cell and compute_global_error() for the whole domain. Let be a finite element function with components where component is denoted by and be the reference function (the fe_function and exact_solution arguments to integrate_difference()). Let be the difference or error between the two. Further, let be the weight function of integrate_difference(), which is assumed to be equal to one if not supplied. Finally, let be the exponent argument (for -norms).
+
In the following,we denote by the local error computed by integrate_difference() on cell , whereas is the global error computed by compute_global_error(). Note that integrals are approximated by quadrature in the usual way:
+
+\]" src="form_2398.png"/>
Similarly for suprema over a cell :
-
+\]" src="form_2399.png"/>
Enumerator
mean
The function or difference of functions is integrated on each cell :
-
+\]" src="form_2400.png"/>
and summed up to get
-
+\]" src="form_2401.png"/>
-
or, for :
-:
+
+\]" src="form_2403.png"/>
-
Note: This differs from what is typically known as the mean of a function by a factor of . To compute the mean you can also use compute_mean_value(). Finally, pay attention to the sign: if , this will compute the negative of the mean of .
+
Note: This differs from what is typically known as the mean of a function by a factor of . To compute the mean you can also use compute_mean_value(). Finally, pay attention to the sign: if , this will compute the negative of the mean of .
L1_norm
The absolute value of the function is integrated:
-
+\]" src="form_2406.png"/>
and
-
+\]" src="form_2407.png"/>
-
or, for :
-:
+
+\]" src="form_2408.png"/>
L2_norm
The square of the function is integrated and the square root of the result is computed on each cell:
-
+\]" src="form_2409.png"/>
and
-
+\]" src="form_2410.png"/>
-
or, for :
-:
+
+\]" src="form_2411.png"/>
-
Lp_norm
The absolute value to the -th power is integrated and the -th root is computed on each cell. The exponent is the exponent argument of integrate_difference() and compute_mean_value():
-Lp_norm
The absolute value to the -th power is integrated and the -th root is computed on each cell. The exponent is the exponent argument of integrate_difference() and compute_mean_value():
L2_norm of the divergence of a vector field. The function is expected to have components and the first dim will be used to compute the divergence:
-Hdiv_seminorm
L2_norm of the divergence of a vector field. The function is expected to have components and the first dim will be used to compute the divergence:
+
+\]" src="form_2422.png"/>
and
-
+\]" src="form_2423.png"/>
-
or, for :
/usr/share/doc/packages/dealii/doxygen/deal.II/namespacehp_1_1Refinement.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespacehp_1_1Refinement.html 2024-12-27 18:25:17.800935510 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespacehp_1_1Refinement.html 2024-12-27 18:25:17.808935565 +0000
@@ -541,7 +541,7 @@
-
Predict how the current error_indicators will adapt after refinement and coarsening were to happen on the provided dof_handler, and write its results to predicted_errors. Each entry of error_indicators and predicted_errors corresponds to an active cell on the underlying Triangulation, thus each container has to be of size Triangulation::n_active_cells(). The errors are interpreted to be measured in the energy norm; this assumption enters the rate of convergence that is used in the prediction. The -norm of the output argument predicted_errors corresponds to the predicted global error after adaptation.
+
Predict how the current error_indicators will adapt after refinement and coarsening were to happen on the provided dof_handler, and write its results to predicted_errors. Each entry of error_indicators and predicted_errors corresponds to an active cell on the underlying Triangulation, thus each container has to be of size Triangulation::n_active_cells(). The errors are interpreted to be measured in the energy norm; this assumption enters the rate of convergence that is used in the prediction. The -norm of the output argument predicted_errors corresponds to the predicted global error after adaptation.
For p-adaptation, the local error is expected to converge exponentially with the polynomial degree of the assigned finite element. Each increase or decrease of the degree will thus change its value by a user-defined control parameter gamma_p.
For h-adaptation, we expect the local error on cell to be proportional to in the energy norm, where denotes the cell diameter and the polynomial degree of the currently assigned finite element on cell .
During h-coarsening, the finite elements on siblings may be different, and their parent cell will be assigned to their least dominating finite element that belongs to its most general child. Thus, we will always interpolate on an enclosing finite element space. Additionally assuming that the finite elements on the cells to be coarsened are sufficient to represent the solution correctly (e.g. at least quadratic basis functions for a quadratic solution), we are confident to say that the error will not change by sole interpolation on the larger finite element space.
On basis of the refinement history, we use the predicted error estimates to decide how cells will be adapted in the next adaptation step. Comparing the predicted error from the previous adaptation step to the error estimates of the current step allows us to justify whether our previous choice of adaptation was justified, and lets us decide how to adapt in the next one.
-
We thus have to transfer the predicted error from the old to the adapted mesh. When transferring the predicted error to the adapted mesh, make sure to configure your CellDataTransfer object with AdaptationStrategies::Refinement::l2_norm() as a refinement strategy and AdaptationStrategies::Coarsening::l2_norm() as a coarsening strategy. This ensures that the -norm of the predict errors is preserved on both meshes.
+
We thus have to transfer the predicted error from the old to the adapted mesh. When transferring the predicted error to the adapted mesh, make sure to configure your CellDataTransfer object with AdaptationStrategies::Refinement::l2_norm() as a refinement strategy and AdaptationStrategies::Coarsening::l2_norm() as a coarsening strategy. This ensures that the -norm of the predict errors is preserved on both meshes.
In this context, we assume that the local error on a cell to be h-refined will be divided equally on all of its children, whereas local errors on siblings will be summed up on the parent cell in case of h-coarsening. This assumption is often not satisfied in practice: For example, if a cell is at a corner singularity, then the one child cell that ends up closest to the singularity will inherit the majority of the remaining error – but this function can not know where the singularity will be, and consequently assumes equal distribution.
Incorporating the transfer from the old to the adapted mesh, the complete error prediction algorithm reads as follows:
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceinternal.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceinternal.html 2024-12-27 18:25:17.936936444 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceinternal.html 2024-12-27 18:25:17.940936471 +0000
@@ -949,8 +949,8 @@
const double
coordinate_value&#href_anchor"memdoc">
Creates a (dim + 1)-dimensional point by copying over the coordinates of the incoming dim-dimensional point and setting the "missing" (dim + 1)-dimensional component to the incoming coordinate value.
-
For example, given the input this function creates the point .
-
The coordinates of the dim-dimensional point are written to the coordinates of the (dim + 1)-dimensional point in the order of the convention given by the function coordinate_to_one_dim_higher. Thus, the order of coordinates on the lower-dimensional point are not preserved: creates the point .
+
For example, given the input this function creates the point .
+
The coordinates of the dim-dimensional point are written to the coordinates of the (dim + 1)-dimensional point in the order of the convention given by the function coordinate_to_one_dim_higher. Thus, the order of coordinates on the lower-dimensional point are not preserved: creates the point .
Compute the polynomial interpolation of a tensor product shape function given a vector of coefficients in the form . The shape functions given a vector of coefficients in the form . The shape functions represent a tensor product. The function returns a pair with the value of the interpolation as the first component and the gradient in reference coordinates as the second component. Note that for compound types (e.g. the values field begin a Point<spacedim> argument), the components of the gradient are sorted as Tensor<1, dim, Tensor<1, spacedim>> with the derivatives as the first index; this is a consequence of the generic arguments in the function.
Parameters
/usr/share/doc/packages/dealii/doxygen/deal.II/namespaceparallel.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceparallel.html 2024-12-27 18:25:17.976936719 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/namespaceparallel.html 2024-12-27 18:25:17.984936774 +0000
@@ -396,7 +396,7 @@
This function works a lot like the apply_to_subranges() function, but it allows to accumulate numerical results computed on each subrange into one number. The type of this number is given by the ResultType template argument that needs to be explicitly specified, and results are added up (i.e., the reduction of results from subranges happens by adding up these results).
-
An example of use of this function is to compute the value of the expression for a square matrix and a vector . The sum over rows can be parallelized and the whole code might look like this:
An example of use of this function is to compute the value of the expression for a square matrix and a vector . The sum over rows can be parallelized and the whole code might look like this:
This would refine all cells for which the -coordinate of the cell's center is greater than zero (the TriaAccessor::center function that we call by dereferencing the cell iterator returns a Point<2> object; subscripting [0] would give the -coordinate, subscripting [1] the -coordinate). By looking at the functions that TriaAccessor provides, you can also use more complicated criteria for refinement.
+
This would refine all cells for which the -coordinate of the cell's center is greater than zero (the TriaAccessor::center function that we call by dereferencing the cell iterator returns a Point<2> object; subscripting [0] would give the -coordinate, subscripting [1] the -coordinate). By looking at the functions that TriaAccessor provides, you can also use more complicated criteria for refinement.
In general, what you can do with operations of the form cell->something() is a bit difficult to find in the documentation because cell is not a pointer but an iterator. The functions you can call on a cell can be found in the documentation of the classes TriaAccessor (which has functions that can also be called on faces of cells or, more generally, all sorts of geometric objects that appear in a triangulation), and CellAccessor (which adds a few functions that are specific to cells).
A more thorough description of the whole iterator concept can be found in the Iterators on mesh-like containers documentation topic.
Different geometries
/usr/share/doc/packages/dealii/doxygen/deal.II/step_10.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_10.html 2024-12-27 18:25:18.060937295 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_10.html 2024-12-27 18:25:18.060937295 +0000
@@ -123,11 +123,11 @@
This is a rather short example which only shows some aspects of using higher order mappings. By mapping we mean the transformation between the unit cell (i.e. the unit line, square, or cube) to the cells in real space. In all the previous examples, we have implicitly used linear or d-linear mappings; you will not have noticed this at all, since this is what happens if you do not do anything special. However, if your domain has curved boundaries, there are cases where the piecewise linear approximation of the boundary (i.e. by straight line segments) is not sufficient, and you want that your computational domain is an approximation to the real domain using curved boundaries as well. If the boundary approximation uses piecewise quadratic parabolas to approximate the true boundary, then we say that this is a quadratic or approximation. If we use piecewise graphs of cubic polynomials, then this is a approximation, and so on.
+
This is a rather short example which only shows some aspects of using higher order mappings. By mapping we mean the transformation between the unit cell (i.e. the unit line, square, or cube) to the cells in real space. In all the previous examples, we have implicitly used linear or d-linear mappings; you will not have noticed this at all, since this is what happens if you do not do anything special. However, if your domain has curved boundaries, there are cases where the piecewise linear approximation of the boundary (i.e. by straight line segments) is not sufficient, and you want that your computational domain is an approximation to the real domain using curved boundaries as well. If the boundary approximation uses piecewise quadratic parabolas to approximate the true boundary, then we say that this is a quadratic or approximation. If we use piecewise graphs of cubic polynomials, then this is a approximation, and so on.
For some differential equations, it is known that piecewise linear approximations of the boundary, i.e. mappings, are not sufficient if the boundary of the exact domain is curved. Examples are the biharmonic equation using elements, or the Euler equations of gas dynamics on domains with curved reflective boundaries. In these cases, it is necessary to compute the integrals using a higher order mapping. If we do not use such a higher order mapping, the order of approximation of the boundary dominates the order of convergence of the entire numerical scheme, irrespective of the order of convergence of the discretization in the interior of the domain.
Rather than demonstrating the use of higher order mappings with one of these more complicated examples, we do only a brief computation: calculating the value of by two different methods.
-
The first method uses a triangulated approximation of the circle with unit radius and integrates a unit magnitude constant function ( ) over it. Of course, if the domain were the exact unit circle, then the area would be , but since we only use an approximation by piecewise polynomial segments, the value of the area we integrate over is not exactly . However, it is known that as we refine the triangulation, a mapping approximates the boundary with an order , where is the mesh size. We will check the values of the computed area of the circle and their convergence towards under mesh refinement for different mappings. We will also find a convergence behavior that is surprising at first, but has a good explanation.
-
The second method works similarly, but this time does not use the area of the triangulated unit circle, but rather its perimeter. is then approximated by half of the perimeter, as we choose the radius equal to one.
+
The first method uses a triangulated approximation of the circle with unit radius and integrates a unit magnitude constant function ( ) over it. Of course, if the domain were the exact unit circle, then the area would be , but since we only use an approximation by piecewise polynomial segments, the value of the area we integrate over is not exactly . However, it is known that as we refine the triangulation, a mapping approximates the boundary with an order , where is the mesh size. We will check the values of the computed area of the circle and their convergence towards under mesh refinement for different mappings. We will also find a convergence behavior that is surprising at first, but has a good explanation.
+
The second method works similarly, but this time does not use the area of the triangulated unit circle, but rather its perimeter. is then approximated by half of the perimeter, as we choose the radius equal to one.
Note
This tutorial shows in essence how to choose a particular mapping for integrals, by attaching a particular geometry to the triangulation (as had already been done in step-1, for example) and then passing a mapping argument to the FEValues class that is used for all integrals in deal.II. The geometry we choose is a circle, for which deal.II already has a class (SphericalManifold) that can be used. If you want to define your own geometry, for example because it is complicated and cannot be described by the classes already available in deal.II, you will want to read through step-53.
The commented program
The first of the following include files are probably well-known by now and need no further explanation.
void hyper_ball(Triangulation< dim > &tria, const Point< dim > ¢er=Point< dim >(), const double radius=1., const bool attach_spherical_manifold_on_boundary_cells=false)
-
Then alternate between generating output on the current mesh for , , and mappings, and (at the end of the loop body) refining the mesh once globally.
+
Then alternate between generating output on the current mesh for , , and mappings, and (at the end of the loop body) refining the mesh once globally.
 for (unsignedint refinement = 0; refinement < 2; ++refinement)
 {
 std::cout << "Refinement level: " << refinement << std::endl;
@@ -205,9 +205,9 @@
 }
 }
Â
-
Now we proceed with the main part of the code, the approximation of . The area of a circle is of course given by , so having a circle of radius 1, the area represents just the number that is searched for. The numerical computation of the area is performed by integrating the constant function of value 1 over the whole computational domain, i.e. by computing the areas . The area of a circle is of course given by , so having a circle of radius 1, the area represents just the number that is searched for. The numerical computation of the area is performed by integrating the constant function of value 1 over the whole computational domain, i.e. by computing the areas , where the sum extends over all quadrature points on all active cells in the triangulation, with being the weight of quadrature point . The integrals on each cell are approximated by numerical quadrature, hence the only additional ingredient we need is to set up a FEValues object that provides the corresponding JxW values of each cell. (Note that JxW is meant to abbreviate Jacobian determinant times weight; since in numerical quadrature the two factors always occur at the same places, we only offer the combined quantity, rather than two separate ones.) We note that here we won't use the FEValues object in its original purpose, i.e. for the computation of values of basis functions of a specific finite element at certain quadrature points. Rather, we use it only to gain the JxW at the quadrature points, irrespective of the (dummy) finite element we will give to the constructor of the FEValues object. The actual finite element given to the FEValues object is not used at all, so we could give any.
+ \ J(\hat x_i)w(\hat x_i)$" src="form_2879.png"/>, where the sum extends over all quadrature points on all active cells in the triangulation, with being the weight of quadrature point . The integrals on each cell are approximated by numerical quadrature, hence the only additional ingredient we need is to set up a FEValues object that provides the corresponding JxW values of each cell. (Note that JxW is meant to abbreviate Jacobian determinant times weight; since in numerical quadrature the two factors always occur at the same places, we only offer the combined quantity, rather than two separate ones.) We note that here we won't use the FEValues object in its original purpose, i.e. for the computation of values of basis functions of a specific finite element at certain quadrature points. Rather, we use it only to gain the JxW at the quadrature points, irrespective of the (dummy) finite element we will give to the constructor of the FEValues object. The actual finite element given to the FEValues object is not used at all, so we could give any.
We employ an object of the ConvergenceTable class to store all important data like the approximated values for and the error with respect to the true value of . We will also use functions provided by the ConvergenceTable class to compute convergence rates of the approximations to .
+
We employ an object of the ConvergenceTable class to store all important data like the approximated values for and the error with respect to the true value of . We will also use functions provided by the ConvergenceTable class to compute convergence rates of the approximations to .
The following, second function also computes an approximation of but this time via the perimeter of the domain instead of the area. This function is only a variation of the previous function. So we will mainly give documentation for the differences.
+
The following, second function also computes an approximation of but this time via the perimeter of the domain instead of the area. This function is only a variation of the previous function. So we will mainly give documentation for the differences.
or using one of the other filenames. The second line makes sure that the aspect ratio of the generated output is actually 1:1, i.e. a circle is drawn as a circle on your screen, rather than as an ellipse. The third line switches off the key in the graphic, as that will only print information (the filename) which is not that important right now. Similarly, the fourth and fifth disable tick marks. The plot is then generated with a specific line width ("lw", here set to 4) and line type ("lt", here chosen by saying that the line should be drawn using the RGB color "black").
-
The following table shows the triangulated computational domain for , , and mappings, for the original coarse grid (left), and a once uniformly refined grid (right).
+
The following table shows the triangulated computational domain for , , and mappings, for the original coarse grid (left), and a once uniformly refined grid (right).
These pictures show the obvious advantage of higher order mappings: they approximate the true boundary quite well also on rather coarse meshes. To demonstrate this a little further, here is part of the upper right quarter circle of the coarse meshes with and mappings, where the dashed red line marks the actual circle:
+ boundary is nearly indistinguishable from the actual circle." style="pointer-events: none;" width="400" height="400" class="inline"/>
These pictures show the obvious advantage of higher order mappings: they approximate the true boundary quite well also on rather coarse meshes. To demonstrate this a little further, here is part of the upper right quarter circle of the coarse meshes with and mappings, where the dashed red line marks the actual circle:
Obviously the quadratic mapping approximates the boundary quite well, while for the cubic mapping the difference between approximated domain and true one is hardly visible already for the coarse grid. You can also see that the mapping only changes something at the outer boundaries of the triangulation. In the interior, all lines are still represented by linear functions, resulting in additional computations only on cells at the boundary. Higher order mappings are therefore usually not noticeably slower than lower order ones, because the additional computations are only performed on a small subset of all cells.
@@ -510,14 +510,14 @@
1280 3.1415926535897896 3.5527e-15 3.32
5120 3.1415926535897940 8.8818e-16 2.00
Note
Once the error reaches a level on the order of to , it is essentially dominated by round-off and consequently dominated by what precisely the library is doing in internal computations. Since these things change, the precise values and errors change from release to release at these round-off levels, though the overall order of errors should of course remain the same. See also the comment below in the section on Possibilities for extensions about how to compute these results more accurately.
-
One of the immediate observations from the output above is that in all cases the values converge quickly to the true value of . Note that for the mapping, we are already in the regime of roundoff errors and the convergence rate levels off, which is already quite a lot. However, also note that for the mapping, even on the finest grid the accuracy is significantly worse than on the coarse grid for a mapping!
+
One of the immediate observations from the output above is that in all cases the values converge quickly to the true value of . Note that for the mapping, we are already in the regime of roundoff errors and the convergence rate levels off, which is already quite a lot. However, also note that for the mapping, even on the finest grid the accuracy is significantly worse than on the coarse grid for a mapping!
The last column of the output shows the convergence order, in powers of the mesh width . In the introduction, we had stated that the convergence order for a mapping should be . However, in the example shown, the order is rather ! This at first surprising fact is explained by the properties of the mapping. At order p, it uses support points that are based on the p+1 point Gauss-Lobatto quadrature rule that selects the support points in such a way that the quadrature rule converges at order 2p. Even though these points are here only used for interpolation of a pth order polynomial, we get a superconvergence effect when numerically evaluating the integral, resulting in the observed high order of convergence. (This effect is also discussed in detail in the following publication: A. Bonito, A. Demlow, and J. Owen: "A priori error
estimates for finite element approximations to eigenvalues and
eigenfunctions of the Laplace-Beltrami operator", submitted, 2018.)
Possibilities for extensions
-
As the table of numbers copied from the output of the program shows above, it is not very difficult to compute the value of to 13 or 15 digits. But, the output also shows that once we approach the level of accuracy with which double precision numbers store information (namely, with roughly 16 digits of accuracy), we no longer see the expected convergence order and the error no longer decreases with mesh refinement as anticipated. This is because both within this code and within the many computations that happen within deal.II itself, each operation incurs an error on the order of ; adding such errors many times over then results in an error that may be on the order of , which will dominate the discretization error after a number of refinement steps and consequently destroy the convergence rate.
-
The question is whether one can do anything about this. One thought is to use a higher-precision data type. For example, one could think of declaring both the area and perimeter variables in compute_pi_by_area() and compute_pi_by_perimeter() with data type long double. long double is a data type that is not well specified in the C++ standard but at least on Intel processors has around 19, instead of around 16, digits of accuracy. If we were to do that, we would get results that differ from the ones shown above. However, maybe counter-intuitively, they are not uniformly better. For example, when computing by the area, at the time of writing these sentences we get these values with double precision for degree 4:
5 3.1415871927401144 5.4608e-06 -
+
As the table of numbers copied from the output of the program shows above, it is not very difficult to compute the value of to 13 or 15 digits. But, the output also shows that once we approach the level of accuracy with which double precision numbers store information (namely, with roughly 16 digits of accuracy), we no longer see the expected convergence order and the error no longer decreases with mesh refinement as anticipated. This is because both within this code and within the many computations that happen within deal.II itself, each operation incurs an error on the order of ; adding such errors many times over then results in an error that may be on the order of , which will dominate the discretization error after a number of refinement steps and consequently destroy the convergence rate.
+
The question is whether one can do anything about this. One thought is to use a higher-precision data type. For example, one could think of declaring both the area and perimeter variables in compute_pi_by_area() and compute_pi_by_perimeter() with data type long double. long double is a data type that is not well specified in the C++ standard but at least on Intel processors has around 19, instead of around 16, digits of accuracy. If we were to do that, we would get results that differ from the ones shown above. However, maybe counter-intuitively, they are not uniformly better. For example, when computing by the area, at the time of writing these sentences we get these values with double precision for degree 4:
5 3.1415871927401144 5.4608e-06 -
20 3.1415926314742491 2.2116e-08 7.95
80 3.1415926535026268 8.7166e-11 7.99
320 3.1415926535894005 3.9257e-13 7.79
@@ -530,7 +530,7 @@
320 3.1415926535894516 3.4157e-13 8.00
1280 3.1415926535897918 1.5339e-15 7.80
5120 3.1415926535897927 5.2649e-16 1.54
-
Indeed, here we get results that are approximately 50 times as accurate. On the other hand, when computing by the perimeter, we get this with double precision:
5 3.1415921029432572 5.5065e-07 -
+
Indeed, here we get results that are approximately 50 times as accurate. On the other hand, when computing by the perimeter, we get this with double precision:
5 3.1415921029432572 5.5065e-07 -
20 3.1415926513737582 2.2160e-09 7.96
80 3.1415926535810699 8.7232e-12 7.99
320 3.1415926535897576 3.5527e-14 7.94
@@ -542,7 +542,7 @@
320 3.1415926535897576 3.5705e-14 7.93
1280 3.1415926535897918 1.3785e-15 4.70
5120 3.1415926535897944 1.3798e-15 -0.00
-
Here, using double precision is more accurate by about a factor of two. (Of course, in all cases, we have computed with more accuracy than any engineer would ever want to know.)
+
Here, using double precision is more accurate by about a factor of two. (Of course, in all cases, we have computed with more accuracy than any engineer would ever want to know.)
What explains this unpredictability? In general, round-off errors can be thought of as random, and add up in ways that are not worth thinking too much about; we should therefore always treat any accuracy beyond, say, thirteen digits as suspect. Thus, it is probably not worth spending too much time on wondering why we get different winners and losers in the data type exchange from double and long double. The accuracy of the results is also largely not determined by the precision of the data type in which we accumulate each cell's (or face's) contributions, but the accuracy of what deal.II gives us via FEValues::JxW() and FEFaceValues::JxW(), which always uses double precision and which we cannot directly affect.
But there are cases where one can do something about the precision, and it is worth at least mentioning the name of the most well-known algorithm in this area. Specifically, what we are doing when we add contributions into the area and perimeter values is that we are adding together positive numbers as we do here. In general, the round-off errors associated with each of these numbers is random, and if we add up contributions of substantially different sizes, then we will likely be dominated by the error in the largest contributions. One can avoid this by adding up numbers sorted by their size, and this may then result in marginally more accurate end results. The algorithm that implements this is typically called Kahan's summation algorithm. While one could play with it in the current context, it is likely not going to improve the accuracy in ways that will truly matter.
We will consider the special case that is the circle of radius 1 around the origin, and , . This choice satisfies the compatibility condition.
+
We will consider the special case that is the circle of radius 1 around the origin, and , . This choice satisfies the compatibility condition.
The compatibility condition allows a solution of the above equation, but it nevertheless retains an ambiguity: since only derivatives of the solution appear in the equations, the solution is only determined up to a constant. For this reason, we have to pose another condition for the numerical solution, which fixes this constant.
For this, there are various possibilities:
@@ -336,7 +336,7 @@
That's quite simple, right?
Two remarks are in order, though: First, these functions are used in a lot of contexts. Maybe you want to create a Laplace or mass matrix for a vector values finite element; or you want to use the default Q1 mapping; or you want to assembled the matrix with a coefficient in the Laplace operator. For this reason, there are quite a large number of variants of these functions in the MatrixCreator and MatrixTools namespaces. Whenever you need a slightly different version of these functions than the ones called above, it is certainly worthwhile to take a look at the documentation and to check whether something fits your needs.
The second remark concerns the quadrature formula we use: we want to integrate over bilinear shape functions, so we know that we have to use at least an order two Gauss quadrature formula. On the other hand, we want the quadrature rule to have at least the order of the boundary approximation. Since the order of Gauss rule with points is , and the order of the boundary approximation using polynomials of degree is , we know that . Since r has to be an integer and (as mentioned above) has to be at least , this makes up for the formula above computing gauss_degree.
+ 1$" src="form_2900.png"/>, and the order of the boundary approximation using polynomials of degree is , we know that . Since r has to be an integer and (as mentioned above) has to be at least , this makes up for the formula above computing gauss_degree.
Since the generation of the body force contributions to the right hand side vector was so simple, we do that all over again for the boundary forces as well: allocate a vector of the right size and call the right function. The boundary function has constant values, so we can generate an object from the library on the fly, and we use the same quadrature formula as above, but this time of lower dimension since we integrate over faces now instead of cells:
/usr/share/doc/packages/dealii/doxygen/deal.II/step_12.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_12.html 2024-12-27 18:25:18.152937927 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_12.html 2024-12-27 18:25:18.156937955 +0000
@@ -157,7 +157,7 @@
u=g\quad\mbox{on }\Gamma_-,
\]" src="form_2903.png"/>
-
on the inflow part of the boundary of the domain. Here, denotes a vector field, the (scalar) solution function, a boundary value function,
+
on the inflow part of the boundary of the domain. Here, denotes a vector field, the (scalar) solution function, a boundary value function,
@@ -837,7 +837,7 @@
There are a number of strategies to stabilize the cG method, if one wants to use continuous elements for some reason. Discussing these methods is beyond the scope of this tutorial program; an interested reader could, for example, take a look at step-31.
Possibilities for extensions
Given that the exact solution is known in this case, one interesting avenue for further extensions would be to confirm the order of convergence for this program. In the current case, the solution is non-smooth, and so we can not expect to get a particularly high order of convergence, even if we used higher order elements. But even if the solution is smooth, the equation is not elliptic and so it is not immediately clear that we should obtain a convergence order that equals that of the optimal interpolation estimates (i.e. for example that we would get convergence in the norm by using quadratic elements).
-
In fact, for hyperbolic equations, theoretical predictions often indicate that the best one can hope for is an order one half below the interpolation estimate. For example, for the streamline diffusion method (an alternative method to the DG method used here to stabilize the solution of the transport equation), one can prove that for elements of degree , the order of convergence is on arbitrary meshes. While the observed order is frequently on uniformly refined meshes, one can construct so-called Peterson meshes on which the worse theoretical bound is actually attained. This should be relatively simple to verify, for example using the VectorTools::integrate_difference function.
+
In fact, for hyperbolic equations, theoretical predictions often indicate that the best one can hope for is an order one half below the interpolation estimate. For example, for the streamline diffusion method (an alternative method to the DG method used here to stabilize the solution of the transport equation), one can prove that for elements of degree , the order of convergence is on arbitrary meshes. While the observed order is frequently on uniformly refined meshes, one can construct so-called Peterson meshes on which the worse theoretical bound is actually attained. This should be relatively simple to verify, for example using the VectorTools::integrate_difference function.
A different direction is to observe that the solution of transport problems often has discontinuities and that therefore a mesh in which we bisect every cell in every coordinate direction may not be optimal. Rather, a better strategy would be to only cut cells in the direction parallel to the discontinuity. This is called anisotropic mesh refinement and is the subject of step-30.
/usr/share/doc/packages/dealii/doxygen/deal.II/step_14.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_14.html 2024-12-27 18:25:18.296938916 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_14.html 2024-12-27 18:25:18.300938943 +0000
@@ -176,30 +176,30 @@
The Heidelberg group of Professor Rolf Rannacher, to which the three initial authors of the deal.II library belonged during their PhD time and partly also afterwards, has been involved with adaptivity and error estimation for finite element discretizations since the mid-1990ies. The main achievement is the development of error estimates for arbitrary functionals of the solution, and of optimal mesh refinement for its computation.
We will not discuss the derivation of these concepts in too great detail, but will implement the main ideas in the present example program. For a thorough introduction into the general idea, we refer to the seminal work of Becker and Rannacher [BR95], [BR96r], and the overview article of the same authors in Acta Numerica [BR01]; the first introduces the concept of error estimation and adaptivity for general functional output for the Laplace equation, while the second gives many examples of applications of these concepts to a large number of other, more complicated equations. For applications to individual types of equations, see also the publications by Becker [Bec95], [Bec98], Kanschat [Kan96], [FK97], Suttmeier [Sut96], [RS97], [RS98c], [RS99], Bangerth [BR99b], [Ban00w], [BR01a], [Ban02], and Hartmann [Har02], [HH01], [HH01b]. All of these works, from the original introduction by Becker and Rannacher to individual contributions to particular equations, have later been summarized in a book by Bangerth and Rannacher that covers all of these topics, see [BR03].
The basic idea is the following: in applications, one is not usually interested in the solution per se, but rather in certain aspects of it. For example, in simulations of flow problems, one may want to know the lift or drag of a body immersed in the fluid; it is this quantity that we want to know to best accuracy, and whether the rest of the solution of the describing equations is well resolved is not of primary interest. Likewise, in elasticity one might want to know about values of the stress at certain points to guess whether maximal load values of joints are safe, for example. Or, in radiative transfer problems, mean flux intensities are of interest.
-
In all the cases just listed, it is the evaluation of a functional of the solution which we are interested in, rather than the values of everywhere. Since the exact solution is not available, but only its numerical approximation , it is sensible to ask whether the computed value is within certain limits of the exact value , i.e. we want to bound the error with respect to this functional, .
-
For simplicity of exposition, we henceforth assume that both the quantity of interest as well as the equation are linear, and we will in particular show the derivation for the Laplace equation with homogeneous Dirichlet boundary conditions, although the concept is much more general. For this general case, we refer to the references listed above. The goal is to obtain bounds on the error, . For this, let us denote by the solution of a dual problem, defined as follows:
- of the solution which we are interested in, rather than the values of everywhere. Since the exact solution is not available, but only its numerical approximation , it is sensible to ask whether the computed value is within certain limits of the exact value , i.e. we want to bound the error with respect to this functional, .
+
For simplicity of exposition, we henceforth assume that both the quantity of interest as well as the equation are linear, and we will in particular show the derivation for the Laplace equation with homogeneous Dirichlet boundary conditions, although the concept is much more general. For this general case, we refer to the references listed above. The goal is to obtain bounds on the error, . For this, let us denote by the solution of a dual problem, defined as follows:
+
+\]" src="form_2946.png"/>
-
where is the bilinear form associated with the differential equation, and the test functions are chosen from the corresponding solution space. Then, taking as special test function the error, we have that
- is the bilinear form associated with the differential equation, and the test functions are chosen from the corresponding solution space. Then, taking as special test function the error, we have that
+
+\]" src="form_2949.png"/>
and we can, by Galerkin orthogonality, rewrite this as
-
+\]" src="form_2950.png"/>
-
where can be chosen from the discrete test space in whatever way we find convenient.
+
where can be chosen from the discrete test space in whatever way we find convenient.
Concretely, for Laplace's equation, the error identity reads
-
+\]" src="form_2952.png"/>
Because we want to use this formula not only to compute error, but also to refine the mesh, we need to rewrite the expression above as a sum over cells where each cell's contribution can then be used as an error indicator for this cell. Thus, we split the scalar products into terms for each cell, and integrate by parts on each of them:
-
+\end{eqnarray*}" src="form_2953.png"/>
-
Next we use that , and that the solution of the Laplace equation is smooth enough that is continuous almost everywhere – so the terms involving on one cell cancels with that on its neighbor, where the normal vector has the opposite sign. (The same is not true for , though.) At the boundary of the domain, where there is no neighbor cell with which this term could cancel, the weight can be chosen as zero, and the whole term disappears.
+
Next we use that , and that the solution of the Laplace equation is smooth enough that is continuous almost everywhere – so the terms involving on one cell cancels with that on its neighbor, where the normal vector has the opposite sign. (The same is not true for , though.) At the boundary of the domain, where there is no neighbor cell with which this term could cancel, the weight can be chosen as zero, and the whole term disappears.
Thus, we have
-
+\end{eqnarray*}" src="form_2958.png"/>
-
In a final step, note that when taking the normal derivative of , we mean the value of this quantity as taken from this side of the cell (for the usual Lagrange elements, derivatives are not continuous across edges). We then rewrite the above formula by exchanging half of the edge integral of cell with the neighbor cell , to obtain
-, we mean the value of this quantity as taken from this side of the cell (for the usual Lagrange elements, derivatives are not continuous across edges). We then rewrite the above formula by exchanging half of the edge integral of cell with the neighbor cell , to obtain
+
+\end{eqnarray*}" src="form_2959.png"/>
-
Using that for the normal vectors on adjacent cells we have , we define the jump of the normal derivative by
-, we define the jump of the normal derivative by
+
+\]" src="form_2961.png"/>
-
and get the final form after setting the discrete function , which is by now still arbitrary, to the point interpolation of the dual solution, :
-, which is by now still arbitrary, to the point interpolation of the dual solution, :
+
+\end{eqnarray*}" src="form_2963.png"/>
-
With this, we have obtained an exact representation of the error of the finite element discretization with respect to arbitrary (linear) functionals . Its structure is a weighted form of a residual estimator, as both and are cell and edge residuals that vanish on the exact solution, and are weights indicating how important the residual on a certain cell is for the evaluation of the given functional. Furthermore, it is a cell-wise quantity, so we can use it as a mesh refinement criterion. The question is: how to evaluate it? After all, the evaluation requires knowledge of the dual solution , which carries the information about the quantity we want to know to best accuracy.
-
In some, very special cases, this dual solution is known. For example, if the functional is the point evaluation, , then the dual solution has to satisfy
-. Its structure is a weighted form of a residual estimator, as both and are cell and edge residuals that vanish on the exact solution, and are weights indicating how important the residual on a certain cell is for the evaluation of the given functional. Furthermore, it is a cell-wise quantity, so we can use it as a mesh refinement criterion. The question is: how to evaluate it? After all, the evaluation requires knowledge of the dual solution , which carries the information about the quantity we want to know to best accuracy.
+
In some, very special cases, this dual solution is known. For example, if the functional is the point evaluation, , then the dual solution has to satisfy
+
+\]" src="form_2969.png"/>
with the Dirac delta function on the right hand side, and the dual solution is the Green's function with respect to the point . For simple geometries, this function is analytically known, and we could insert it into the error representation formula.
-
However, we do not want to restrict ourselves to such special cases. Rather, we will compute the dual solution numerically, and approximate by some numerically obtained . We note that it is not sufficient to compute this approximation using the same method as used for the primal solution , since then , and the overall error estimate would be zero. Rather, the approximation has to be from a larger space than the primal finite element space. There are various ways to obtain such an approximation (see the cited literature), and we will choose to compute it with a higher order finite element space. While this is certainly not the most efficient way, it is simple since we already have all we need to do that in place, and it also allows for simple experimenting. For more efficient methods, again refer to the given literature, in particular [BR95], [BR03].
+
However, we do not want to restrict ourselves to such special cases. Rather, we will compute the dual solution numerically, and approximate by some numerically obtained . We note that it is not sufficient to compute this approximation using the same method as used for the primal solution , since then , and the overall error estimate would be zero. Rather, the approximation has to be from a larger space than the primal finite element space. There are various ways to obtain such an approximation (see the cited literature), and we will choose to compute it with a higher order finite element space. While this is certainly not the most efficient way, it is simple since we already have all we need to do that in place, and it also allows for simple experimenting. For more efficient methods, again refer to the given literature, in particular [BR95], [BR03].
With this, we end the discussion of the mathematical side of this program and turn to the actual implementation.
-
Note
There are two steps above that do not seem necessary if all you care about is computing the error: namely, (i) the subtraction of from , and (ii) splitting the integral into a sum of cells and integrating by parts on each. Indeed, neither of these two steps change at all, as we only ever consider identities above until the substitution of by . In other words, if you care only about estimating the global error, then these steps are not necessary. On the other hand, if you want to use the error estimate also as a refinement criterion for each cell of the mesh, then it is necessary to (i) break the estimate into a sum of cells, and (ii) massage the formulas in such a way that each cell's contributions have something to do with the local error. (While the contortions above do not change the value of the sum, they change the values we compute for each cell .) To this end, we want to write everything in the form "residual times dual weight" where a "residual" is something that goes to zero as the approximation becomes better and better. For example, the quantity is not a residual, since it simply converges to the (normal component of) the gradient of the exact solution. On the other hand, is a residual because it converges to . All of the steps we have taken above in developing the final form of have indeed had the goal of bringing the final formula into a form where each term converges to zero as the discrete solution converges to . This then allows considering each cell's contribution as an "error indicator" that also converges to zero – as it should as the mesh is refined.
+
Note
There are two steps above that do not seem necessary if all you care about is computing the error: namely, (i) the subtraction of from , and (ii) splitting the integral into a sum of cells and integrating by parts on each. Indeed, neither of these two steps change at all, as we only ever consider identities above until the substitution of by . In other words, if you care only about estimating the global error, then these steps are not necessary. On the other hand, if you want to use the error estimate also as a refinement criterion for each cell of the mesh, then it is necessary to (i) break the estimate into a sum of cells, and (ii) massage the formulas in such a way that each cell's contributions have something to do with the local error. (While the contortions above do not change the value of the sum, they change the values we compute for each cell .) To this end, we want to write everything in the form "residual times dual weight" where a "residual" is something that goes to zero as the approximation becomes better and better. For example, the quantity is not a residual, since it simply converges to the (normal component of) the gradient of the exact solution. On the other hand, is a residual because it converges to . All of the steps we have taken above in developing the final form of have indeed had the goal of bringing the final formula into a form where each term converges to zero as the discrete solution converges to . This then allows considering each cell's contribution as an "error indicator" that also converges to zero – as it should as the mesh is refined.
The software
The step-14 example program builds heavily on the techniques already used in the step-13 program. Its implementation of the dual weighted residual error estimator explained above is done by deriving a second class, properly called DualSolver, from the Solver base class, and having a class (WeightedResidual) that joins the two again and controls the solution of the primal and dual problem, and then uses both to compute the error indicator for mesh refinement.
The program continues the modular concept of the previous example, by implementing the dual functional, describing quantity of interest, by an abstract base class, and providing two different functionals which implement this interface. Adding a different quantity of interest is thus simple.
@@ -2587,15 +2587,15 @@
Note the subtle interplay between resolving the corner singularities, and resolving around the point of evaluation. It will be rather difficult to generate such a mesh by hand, as this would involve to judge quantitatively how much which of the four corner singularities should be resolved, and to set the weight compared to the vicinity of the evaluation point.
The program prints the point value and the estimated error in this quantity. From extrapolating it, we can guess that the exact value is somewhere close to 0.0334473, plus or minus 0.0000001 (note that we get almost 6 valid digits from only 22,000 (primal) degrees of freedom. This number cannot be obtained from the value of the functional alone, but I have used the assumption that the error estimator is mostly exact, and extrapolated the computed value plus the estimated error, to get an approximation of the true value. Computing with more degrees of freedom shows that this assumption is indeed valid.
-
From the computed results, we can generate two graphs: one that shows the convergence of the error (taking the extrapolated value as correct) in the point value, and the value that we get by adding up computed value and estimated error eta (if the error estimator were exact, then the value would equal the exact point value, and the error in this quantity would always be zero; however, since the error estimator is only a - good - approximation to the true error, we can by this only reduce the size of the error). In this graph, we also indicate the complexity to show that mesh refinement acts optimal in this case. The second chart compares true and estimated error, and shows that the two are actually very close to each other, even for such a complicated quantity as the point value:
+
From the computed results, we can generate two graphs: one that shows the convergence of the error (taking the extrapolated value as correct) in the point value, and the value that we get by adding up computed value and estimated error eta (if the error estimator were exact, then the value would equal the exact point value, and the error in this quantity would always be zero; however, since the error estimator is only a - good - approximation to the true error, we can by this only reduce the size of the error). In this graph, we also indicate the complexity to show that mesh refinement acts optimal in this case. The second chart compares true and estimated error, and shows that the two are actually very close to each other, even for such a complicated quantity as the point value:
Comparing refinement criteria
-
Since we have accepted quite some effort when using the mesh refinement driven by the dual weighted error estimator (for solving the dual problem, and for evaluating the error representation), it is worth while asking whether that effort was successful. To this end, we first compare the achieved error levels for different mesh refinement criteria. To generate this data, simply change the value of the mesh refinement criterion variable in the main program. The results are thus (for the weight in the Kelly indicator, we have chosen the function , where is the distance to the evaluation point; it can be shown that this is the optimal weight if we neglect the effects of boundaries):
+
Since we have accepted quite some effort when using the mesh refinement driven by the dual weighted error estimator (for solving the dual problem, and for evaluating the error representation), it is worth while asking whether that effort was successful. To this end, we first compare the achieved error levels for different mesh refinement criteria. To generate this data, simply change the value of the mesh refinement criterion variable in the main program. The results are thus (for the weight in the Kelly indicator, we have chosen the function , where is the distance to the evaluation point; it can be shown that this is the optimal weight if we neglect the effects of boundaries):
-
Checking these numbers, we see that for global refinement, the error is proportional to , and for the dual estimator . Generally speaking, we see that the dual weighted error estimator is better than the other refinement indicators, at least when compared with those that have a similarly regular behavior. The Kelly indicator produces smaller errors, but jumps about the picture rather irregularly, with the error also changing signs sometimes. Therefore, its behavior does not allow to extrapolate the results to larger values of N. Furthermore, if we trust the error estimates of the dual weighted error estimator, the results can be improved by adding the estimated error to the computed values. In terms of reliability, the weighted estimator is thus better than the Kelly indicator, although the latter sometimes produces smaller errors.
+
Checking these numbers, we see that for global refinement, the error is proportional to , and for the dual estimator . Generally speaking, we see that the dual weighted error estimator is better than the other refinement indicators, at least when compared with those that have a similarly regular behavior. The Kelly indicator produces smaller errors, but jumps about the picture rather irregularly, with the error also changing signs sometimes. Therefore, its behavior does not allow to extrapolate the results to larger values of N. Furthermore, if we trust the error estimates of the dual weighted error estimator, the results can be improved by adding the estimated error to the computed values. In terms of reliability, the weighted estimator is thus better than the Kelly indicator, although the latter sometimes produces smaller errors.
Evaluation of point stresses
Besides evaluating the values of the solution at a certain point, the program also offers the possibility to evaluate the x-derivatives at a certain point, and also to tailor mesh refinement for this. To let the program compute these quantities, simply replace the two occurrences of PointValueEvaluation in the main function by PointXDerivativeEvaluation, and let the program run:
Refinement cycle: 0
Number of degrees of freedom: 72
@@ -2647,16 +2647,16 @@
-
Note the asymmetry of the grids compared with those we obtained for the point evaluation. This is due to the fact that the domain and the primal solution may be symmetric about the diagonal, but the -derivative is not, and the latter enters the refinement criterion.
-
Then, it is interesting to compare actually computed values of the quantity of interest (i.e. the x-derivative of the solution at one point) with a reference value of -0.0528223... plus or minus 0.0000005. We get this reference value by computing on finer grid after some more mesh refinements, with approximately 130,000 cells. Recall that if the error is in the optimal case, then taking a mesh with ten times more cells gives us one additional digit in the result.
+
Note the asymmetry of the grids compared with those we obtained for the point evaluation. This is due to the fact that the domain and the primal solution may be symmetric about the diagonal, but the -derivative is not, and the latter enters the refinement criterion.
+
Then, it is interesting to compare actually computed values of the quantity of interest (i.e. the x-derivative of the solution at one point) with a reference value of -0.0528223... plus or minus 0.0000005. We get this reference value by computing on finer grid after some more mesh refinements, with approximately 130,000 cells. Recall that if the error is in the optimal case, then taking a mesh with ten times more cells gives us one additional digit in the result.
In the left part of the following chart, you again see the convergence of the error towards this extrapolated value, while on the right you see a comparison of true and estimated error:
-
After an initial phase where the true error changes its sign, the estimated error matches it quite well, again. Also note the dramatic improvement in the error when using the estimated error to correct the computed value of .
+
After an initial phase where the true error changes its sign, the estimated error matches it quite well, again. Also note the dramatic improvement in the error when using the estimated error to correct the computed value of .
step-13 revisited
-
If instead of the Exercise_2_3 data set, we choose CurvedRidges in the main function, and choose as the evaluation point, then we can redo the computations of the previous example program, to compare whether the results obtained with the help of the dual weighted error estimator are better than those we had previously.
+
If instead of the Exercise_2_3 data set, we choose CurvedRidges in the main function, and choose as the evaluation point, then we can redo the computations of the previous example program, to compare whether the results obtained with the help of the dual weighted error estimator are better than those we had previously.
First, the meshes after 9 adaptive refinement cycles obtained with the point evaluation and derivative evaluation refinement criteria, respectively, look like this:
/usr/share/doc/packages/dealii/doxygen/deal.II/step_15.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_15.html 2024-12-27 18:25:18.356939328 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_15.html 2024-12-27 18:25:18.360939355 +0000
@@ -156,41 +156,41 @@
Introduction
Foreword
-
This program deals with an example of a non-linear elliptic partial differential equation, the minimal surface equation. You can imagine the solution of this equation to describe the surface spanned by a soap film that is enclosed by a closed wire loop. We imagine the wire to not just be a planar loop, but in fact curved. The surface tension of the soap film will then reduce the surface to have minimal surface. The solution of the minimal surface equation describes this shape with the wire's vertical displacement as a boundary condition. For simplicity, we will here assume that the surface can be written as a graph although it is clear that it is not very hard to construct cases where the wire is bent in such a way that the surface can only locally be constructed as a graph but not globally.
+
This program deals with an example of a non-linear elliptic partial differential equation, the minimal surface equation. You can imagine the solution of this equation to describe the surface spanned by a soap film that is enclosed by a closed wire loop. We imagine the wire to not just be a planar loop, but in fact curved. The surface tension of the soap film will then reduce the surface to have minimal surface. The solution of the minimal surface equation describes this shape with the wire's vertical displacement as a boundary condition. For simplicity, we will here assume that the surface can be written as a graph although it is clear that it is not very hard to construct cases where the wire is bent in such a way that the surface can only locally be constructed as a graph but not globally.
Because the equation is non-linear, we can't solve it directly. Rather, we have to use Newton's method to compute the solution iteratively.
In a classical sense, the problem is given in the following form:
-
+ \end{align*}" src="form_2984.png"/>
-
is the domain we get by projecting the wire's positions into space. In this example, we choose as the unit disk.
-
As described above, we solve this equation using Newton's method in which we compute the th approximate solution from the th one, and use a damping parameter to get better global convergence behavior:
- is the domain we get by projecting the wire's positions into space. In this example, we choose as the unit disk.
+
As described above, we solve this equation using Newton's method in which we compute the th approximate solution from the th one, and use a damping parameter to get better global convergence behavior:
+
+ \end{align*}" src="form_2988.png"/>
with
-
+ \]" src="form_2989.png"/>
-
and the derivative of F in direction of :
- the derivative of F in direction of :
+
+\]" src="form_2992.png"/>
-
Going through the motions to find out what is, we find that we have to solve a linear elliptic PDE in every Newton step, with as the solution of:
+
Going through the motions to find out what is, we find that we have to solve a linear elliptic PDE in every Newton step, with as the solution of:
-
+ \]" src="form_2994.png"/>
-
In order to solve the minimal surface equation, we have to solve this equation repeatedly, once per Newton step. To solve this, we have to take a look at the boundary condition of this problem. Assuming that already has the right boundary values, the Newton update should have zero boundary conditions, in order to have the right boundary condition after adding both. In the first Newton step, we are starting with the solution , the Newton update still has to deliver the right boundary condition to the solution .
-
Summing up, we have to solve the PDE above with the boundary condition in the first step and with in all the following steps.
-
Note
In some sense, one may argue that if the program already implements , it is duplicative to also have to implement . As always, duplication tempts bugs and we would like to avoid it. While we do not explore this issue in this program, we will come back to it at the end of the Possibilities for extensions section below, and specifically in step-72.
+
In order to solve the minimal surface equation, we have to solve this equation repeatedly, once per Newton step. To solve this, we have to take a look at the boundary condition of this problem. Assuming that already has the right boundary values, the Newton update should have zero boundary conditions, in order to have the right boundary condition after adding both. In the first Newton step, we are starting with the solution , the Newton update still has to deliver the right boundary condition to the solution .
+
Summing up, we have to solve the PDE above with the boundary condition in the first step and with in all the following steps.
+
Note
In some sense, one may argue that if the program already implements , it is duplicative to also have to implement . As always, duplication tempts bugs and we would like to avoid it. While we do not explore this issue in this program, we will come back to it at the end of the Possibilities for extensions section below, and specifically in step-72.
Weak formulation of the problem
-
Starting with the strong formulation above, we get the weak formulation by multiplying both sides of the PDE with a test function and integrating by parts on both sides:
- and integrating by parts on both sides:
+
+ \]" src="form_3002.png"/>
-
Here the solution is a function in , subject to the boundary conditions discussed above. Reducing this space to a finite dimensional space with basis , we can write the solution:
+
Here the solution is a function in , subject to the boundary conditions discussed above. Reducing this space to a finite dimensional space with basis , we can write the solution:
-
+\]" src="form_3005.png"/>
-
Using the basis functions as test functions and defining , we can rewrite the weak formulation:
+
Using the basis functions as test functions and defining , we can rewrite the weak formulation:
-
+\]" src="form_3007.png"/>
-
where the solution is given by the coefficients . This linear system of equations can be rewritten as:
+
where the solution is given by the coefficients . This linear system of equations can be rewritten as:
-
+\]" src="form_3009.png"/>
-
where the entries of the matrix are given by:
+
where the entries of the matrix are given by:
-
+\]" src="form_3011.png"/>
-
and the right hand side is given by:
+
and the right hand side is given by:
-
+\]" src="form_3013.png"/>
Questions about the appropriate solver
The matrix that corresponds to the Newton step above can be reformulated to show its structure a bit better. Rewriting it slightly, we get that it has the form
-
+\]" src="form_3014.png"/>
-
where the matrix (of size in space dimensions) is given by the following expression:
- (of size in space dimensions) is given by the following expression:
+
+\]" src="form_3016.png"/>
-
From this expression, it is obvious that is symmetric, and so is symmetric as well. On the other hand, is also positive definite, which confers the same property onto . This can be seen by noting that the vector is an eigenvector of with eigenvalue while all vectors that are perpendicular to and each other are eigenvectors with eigenvalue . Since all eigenvalues are positive, is positive definite and so is . We can thus use the CG method for solving the Newton steps. (The fact that the matrix is symmetric and positive definite should not come as a surprise. It results from taking the derivative of an operator that results from taking the derivative of an energy functional: the minimal surface equation simply minimizes some non-quadratic energy. Consequently, the Newton matrix, as the matrix of second derivatives of a scalar energy, must be symmetric since the derivative with regard to the th and th degree of freedom should clearly commute. Likewise, if the energy functional is convex, then the matrix of second derivatives must be positive definite, and the direct calculation above simply reaffirms this.)
-
It is worth noting, however, that the positive definiteness degenerates for problems where becomes large. In other words, if we simply multiply all boundary values by 2, then to first order and will also be multiplied by two, but as a consequence the smallest eigenvalue of will become smaller and the matrix will become more ill-conditioned. (More specifically, for we have that whereas ; thus, the condition number of , which is a multiplicative factor in the condition number of grows like .) It is simple to verify with the current program that indeed multiplying the boundary values used in the current program by larger and larger values results in a problem that will ultimately no longer be solvable using the simple preconditioned CG method we use here.
+
From this expression, it is obvious that is symmetric, and so is symmetric as well. On the other hand, is also positive definite, which confers the same property onto . This can be seen by noting that the vector is an eigenvector of with eigenvalue while all vectors that are perpendicular to and each other are eigenvectors with eigenvalue . Since all eigenvalues are positive, is positive definite and so is . We can thus use the CG method for solving the Newton steps. (The fact that the matrix is symmetric and positive definite should not come as a surprise. It results from taking the derivative of an operator that results from taking the derivative of an energy functional: the minimal surface equation simply minimizes some non-quadratic energy. Consequently, the Newton matrix, as the matrix of second derivatives of a scalar energy, must be symmetric since the derivative with regard to the th and th degree of freedom should clearly commute. Likewise, if the energy functional is convex, then the matrix of second derivatives must be positive definite, and the direct calculation above simply reaffirms this.)
+
It is worth noting, however, that the positive definiteness degenerates for problems where becomes large. In other words, if we simply multiply all boundary values by 2, then to first order and will also be multiplied by two, but as a consequence the smallest eigenvalue of will become smaller and the matrix will become more ill-conditioned. (More specifically, for we have that whereas ; thus, the condition number of , which is a multiplicative factor in the condition number of grows like .) It is simple to verify with the current program that indeed multiplying the boundary values used in the current program by larger and larger values results in a problem that will ultimately no longer be solvable using the simple preconditioned CG method we use here.
Choice of step length and globalization
-
As stated above, Newton's method works by computing a direction and then performing the update with a step length . It is a common observation that for strongly nonlinear models, Newton's method does not converge if we always choose unless one starts with an initial guess that is sufficiently close to the solution of the nonlinear problem. In practice, we don't always have such an initial guess, and consequently taking full Newton steps (i.e., using ) does frequently not work.
-
A common strategy therefore is to use a smaller step length for the first few steps while the iterate is still far away from the solution and as we get closer use larger values for until we can finally start to use full steps as we are close enough to the solution. The question is of course how to choose . There are basically two widely used approaches: line search and trust region methods.
+
As stated above, Newton's method works by computing a direction and then performing the update with a step length . It is a common observation that for strongly nonlinear models, Newton's method does not converge if we always choose unless one starts with an initial guess that is sufficiently close to the solution of the nonlinear problem. In practice, we don't always have such an initial guess, and consequently taking full Newton steps (i.e., using ) does frequently not work.
+
A common strategy therefore is to use a smaller step length for the first few steps while the iterate is still far away from the solution and as we get closer use larger values for until we can finally start to use full steps as we are close enough to the solution. The question is of course how to choose . There are basically two widely used approaches: line search and trust region methods.
In this program, we simply always choose the step length equal to 0.1. This makes sure that for the testcase at hand we do get convergence although it is clear that by not eventually reverting to full step lengths we forego the rapid, quadratic convergence that makes Newton's method so appealing. Obviously, this is a point one eventually has to address if the program was made into one that is meant to solve more realistic problems. We will comment on this issue some more in the results section, and use an even better approach in step-77.
Summary of the algorithm and testcase
Overall, the program we have here is not unlike step-6 in many regards. The layout of the main class is essentially the same. On the other hand, the driving algorithm in the run() function is different and works as follows:
-
Start with the function and modify it in such a way that the values of along the boundary equal the correct boundary values (this happens in the call to AffineConstraints::distribute()). Set .
+
Start with the function and modify it in such a way that the values of along the boundary equal the correct boundary values (this happens in the call to AffineConstraints::distribute()). Set .
-
Compute the Newton update by solving the system with boundary condition on .
+
Compute the Newton update by solving the system with boundary condition on .
-
Compute a step length . In this program, we always set . To make things easier to extend later on, this happens in a function of its own, namely in MinimalSurfaceProblem::determine_step_length. (The strategy of always choosing is of course not optimal – we should choose a step length that works for a given search direction – but it requires a bit of work to do that. In the end, we leave these sorts of things to external packages: step-77 does that.)
+
Compute a step length . In this program, we always set . To make things easier to extend later on, this happens in a function of its own, namely in MinimalSurfaceProblem::determine_step_length. (The strategy of always choosing is of course not optimal – we should choose a step length that works for a given search direction – but it requires a bit of work to do that. In the end, we leave these sorts of things to external packages: step-77 does that.)
/usr/share/doc/packages/dealii/doxygen/deal.II/step_16.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_16.html 2024-12-27 18:25:18.408939685 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_16.html 2024-12-27 18:25:18.412939712 +0000
@@ -153,7 +153,7 @@
-
The fine level in this mesh consists only of the degrees of freedom that are defined on the refined cells, but does not extend to that part of the domain that is not refined. While this guarantees that the overall effort grows as as necessary for optimal multigrid complexity, it leads to problems when defining where to smooth and what boundary conditions to pose for the operators defined on individual levels if the level boundary is not an external boundary. These questions are discussed in detail in the article cited above.
+
The fine level in this mesh consists only of the degrees of freedom that are defined on the refined cells, but does not extend to that part of the domain that is not refined. While this guarantees that the overall effort grows as as necessary for optimal multigrid complexity, it leads to problems when defining where to smooth and what boundary conditions to pose for the operators defined on individual levels if the level boundary is not an external boundary. These questions are discussed in detail in the article cited above.
The testcase
The problem we solve here is similar to step-6, with two main differences: first, the multigrid preconditioner, obviously. We also change the discontinuity of the coefficients such that the local assembler does not look more complicated than necessary.
The commented program
/usr/share/doc/packages/dealii/doxygen/deal.II/step_18.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_18.html 2024-12-27 18:25:18.496940289 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_18.html 2024-12-27 18:25:18.500940317 +0000
@@ -167,23 +167,23 @@
Quasistatic elastic deformation
Motivation of the model
In general, time-dependent small elastic deformations are described by the elastic wave equation
-
+\]" src="form_3065.png"/>
-
where is the deformation of the body, and the density and attenuation coefficient, and external forces. In addition, initial conditions
- is the deformation of the body, and the density and attenuation coefficient, and external forces. In addition, initial conditions
+
+\]" src="form_3068.png"/>
and Dirichlet (displacement) or Neumann (traction) boundary conditions need to be specified for a unique solution:
-
+\end{eqnarray*}" src="form_3069.png"/>
-
In above formulation, is the symmetric gradient of the displacement, also called the strain. is a tensor of rank 4, called the stress-strain tensor (the inverse of the compliance tensor) that contains knowledge of the elastic strength of the material; its symmetry properties make sure that it maps symmetric tensors of rank 2 (“matrices” of dimension , where is the spatial dimensionality) onto symmetric tensors of the same rank. We will comment on the roles of the strain and stress tensors more below. For the moment it suffices to say that we interpret the term as the vector with components , where summation over indices is implied.
-
The quasistatic limit of this equation is motivated as follows: each small perturbation of the body, for example by changes in boundary condition or the forcing function, will result in a corresponding change in the configuration of the body. In general, this will be in the form of waves radiating away from the location of the disturbance. Due to the presence of the damping term, these waves will be attenuated on a time scale of, say, . Now, assume that all changes in external forcing happen on times scales that are much larger than . In that case, the dynamic nature of the change is unimportant: we can consider the body to always be in static equilibrium, i.e. we can assume that at all times the body satisfies
- is the symmetric gradient of the displacement, also called the strain. is a tensor of rank 4, called the stress-strain tensor (the inverse of the compliance tensor) that contains knowledge of the elastic strength of the material; its symmetry properties make sure that it maps symmetric tensors of rank 2 (“matrices” of dimension , where is the spatial dimensionality) onto symmetric tensors of the same rank. We will comment on the roles of the strain and stress tensors more below. For the moment it suffices to say that we interpret the term as the vector with components , where summation over indices is implied.
+
The quasistatic limit of this equation is motivated as follows: each small perturbation of the body, for example by changes in boundary condition or the forcing function, will result in a corresponding change in the configuration of the body. In general, this will be in the form of waves radiating away from the location of the disturbance. Due to the presence of the damping term, these waves will be attenuated on a time scale of, say, . Now, assume that all changes in external forcing happen on times scales that are much larger than . In that case, the dynamic nature of the change is unimportant: we can consider the body to always be in static equilibrium, i.e. we can assume that at all times the body satisfies
+
+\end{eqnarray*}" src="form_3075.png"/>
-
Note that the differential equation does not contain any time derivatives any more – all time dependence is introduced through boundary conditions and a possibly time-varying force function . The changes in configuration can therefore be considered as being stationary instantaneously. An alternative view of this is that is not really a time variable, but only a time-like parameter that governs the evolution of the problem.
+
Note that the differential equation does not contain any time derivatives any more – all time dependence is introduced through boundary conditions and a possibly time-varying force function . The changes in configuration can therefore be considered as being stationary instantaneously. An alternative view of this is that is not really a time variable, but only a time-like parameter that governs the evolution of the problem.
While these equations are sufficient to describe small deformations, computing large deformations is a little more complicated and, in general, leads to nonlinear equations such as those treated in step-44. In the following, let us consider some of the tools one would employ when simulating problems in which the deformation becomes large.
Note
The model we will consider below is not founded on anything that would be mathematically sound: we will consider a model in which we produce a small deformation, deform the physical coordinates of the body by this deformation, and then consider the next loading step again as a linear problem. This isn't consistent, since the assumption of linearity implies that deformations are infinitesimal and so moving around the vertices of our mesh by a finite amount before solving the next linear problem is an inconsistent approach. We should therefore note that it is not surprising that the equations discussed below can't be found in the literature: The model considered here has little to do with reality! On the other hand, the implementation techniques we consider are very much what one would need to use when implementing a real model, as we will see in step-44.
-
To come back to defining our "artificial" model, let us first introduce a tensorial stress variable , and write the differential equations in terms of the stress:
-, and write the differential equations in terms of the stress:
+
+\end{eqnarray*}" src="form_3077.png"/>
-
Note that these equations are posed on a domain that changes with time, with the boundary moving according to the displacements of the points on the boundary. To complete this system, we have to specify the incremental relationship between the stress and the strain, as follows:
- that changes with time, with the boundary moving according to the displacements of the points on the boundary. To complete this system, we have to specify the incremental relationship between the stress and the strain, as follows:
+
+\]" src="form_3080.png"/>
-
where a dot indicates a time derivative. Both the stress and the strain are symmetric tensors of rank 2.
+
where a dot indicates a time derivative. Both the stress and the strain are symmetric tensors of rank 2.
Time discretization
-
Numerically, this system is solved as follows: first, we discretize the time component using a backward Euler scheme. This leads to a discrete equilibrium of force at time step :
-:
+
+\]" src="form_3082.png"/>
where
-
+\]" src="form_3083.png"/>
-
and the incremental displacement for time step . In addition, we have to specify initial data . This way, if we want to solve for the displacement increment, we have to solve the following system:
- the incremental displacement for time step . In addition, we have to specify initial data . This way, if we want to solve for the displacement increment, we have to solve the following system:
+
+\end{align*}" src="form_3086.png"/>
-
The weak form of this set of equations, which as usual is the basis for the finite element formulation, reads as follows: find such that
- such that
+
+\end{align*}" src="form_3088.png"/>
-
Using that , these equations can be simplified to
-, these equations can be simplified to
+
+\end{align*}" src="form_3090.png"/>
-
We note that, for simplicity, in the program we will always assume that there are no boundary forces, i.e. , and that the deformation of the body is driven by body forces and prescribed boundary displacements alone. It is also worth noting that when integrating by parts, we would get terms of the form , but that we replace them with the term involving the symmetric gradient instead of . Due to the symmetry of , the two terms are mathematically equivalent, but the symmetric version avoids the potential for round-off errors making the resulting matrix slightly non-symmetric.
-
The system at time step , to be solved on the old domain , has exactly the form of a stationary elastic problem, and is therefore similar to what we have already implemented in previous example programs. We will therefore not comment on the space discretization beyond saying that we again use lowest order continuous finite elements.
+
We note that, for simplicity, in the program we will always assume that there are no boundary forces, i.e. , and that the deformation of the body is driven by body forces and prescribed boundary displacements alone. It is also worth noting that when integrating by parts, we would get terms of the form , but that we replace them with the term involving the symmetric gradient instead of . Due to the symmetry of , the two terms are mathematically equivalent, but the symmetric version avoids the potential for round-off errors making the resulting matrix slightly non-symmetric.
+
The system at time step , to be solved on the old domain , has exactly the form of a stationary elastic problem, and is therefore similar to what we have already implemented in previous example programs. We will therefore not comment on the space discretization beyond saying that we again use lowest order continuous finite elements.
There are differences, however:
We have to move (update) the mesh after each time step, in order to be able to solve the next time step on a new domain;
-We need to know to compute the next incremental displacement, i.e. we need to compute it at the end of the time step to make sure it is available for the next time step. Essentially, the stress variable is our window to the history of deformation of the body.
+We need to know to compute the next incremental displacement, i.e. we need to compute it at the end of the time step to make sure it is available for the next time step. Essentially, the stress variable is our window to the history of deformation of the body.
These two operations are done in the functions move_mesh and update_quadrature_point_history in the program. While moving the mesh is only a technicality, updating the stress is a little more complicated and will be discussed in the next section.
Updating the stress variable
-
As indicated above, we need to have the stress variable available when computing time step , and we can compute it using
- available when computing time step , and we can compute it using
+
+\]" src="form_3099.png"/>
-
There are, despite the apparent simplicity of this equation, two questions that we need to discuss. The first concerns the way we store : even if we compute the incremental updates using lowest-order finite elements, then its symmetric gradient is in general still a function that is not easy to describe. In particular, it is not a piecewise constant function, and on general meshes (with cells that are not rectangles parallel to the coordinate axes) or with non-constant stress-strain tensors it is not even a bi- or trilinear function. Thus, it is a priori not clear how to store in a computer program.
-
To decide this, we have to see where it is used. The only place where we require the stress is in the term . In practice, we of course replace this term by numerical quadrature:
-: even if we compute the incremental updates using lowest-order finite elements, then its symmetric gradient is in general still a function that is not easy to describe. In particular, it is not a piecewise constant function, and on general meshes (with cells that are not rectangles parallel to the coordinate axes) or with non-constant stress-strain tensors it is not even a bi- or trilinear function. Thus, it is a priori not clear how to store in a computer program.
+
To decide this, we have to see where it is used. The only place where we require the stress is in the term . In practice, we of course replace this term by numerical quadrature:
+
+\]" src="form_3103.png"/>
-
where are the quadrature weights and the quadrature points on cell . This should make clear that what we really need is not the stress in itself, but only the values of the stress in the quadrature points on all cells. This, however, is a simpler task: we only have to provide a data structure that is able to hold one symmetric tensor of rank 2 for each quadrature point on all cells (or, since we compute in parallel, all quadrature points of all cells that the present MPI process “owns”). At the end of each time step we then only have to evaluate , multiply it by the stress-strain tensor , and use the result to update the stress at quadrature point .
-
The second complication is not visible in our notation as chosen above. It is due to the fact that we compute on the domain , and then use this displacement increment to both update the stress as well as move the mesh nodes around to get to on which the next increment is computed. What we have to make sure, in this context, is that moving the mesh does not only involve moving around the nodes, but also making corresponding changes to the stress variable: the updated stress is a variable that is defined with respect to the coordinate system of the material in the old domain, and has to be transferred to the new domain. The reason for this can be understood as follows: locally, the incremental deformation can be decomposed into three parts, a linear translation (the constant part of the displacement increment field in the neighborhood of a point), a dilational component (that part of the gradient of the displacement field that has a nonzero divergence), and a rotation. A linear translation of the material does not affect the stresses that are frozen into it – the stress values are simply translated along. The dilational or compressional change produces a corresponding stress update. However, the rotational component does not necessarily induce a nonzero stress update (think, in 2d, for example of the situation where , with which ). Nevertheless, if the material was prestressed in a certain direction, then this direction will be rotated along with the material. To this end, we have to define a rotation matrix that describes, in each point the rotation due to the displacement increments. It is not hard to see that the actual dependence of on can only be through the curl of the displacement, rather than the displacement itself or its full gradient (as mentioned above, the constant components of the increment describe translations, its divergence the dilational modes, and the curl the rotational modes). Since the exact form of is cumbersome, we only state it in the program code, and note that the correct updating formula for the stress variable is then
- are the quadrature weights and the quadrature points on cell . This should make clear that what we really need is not the stress in itself, but only the values of the stress in the quadrature points on all cells. This, however, is a simpler task: we only have to provide a data structure that is able to hold one symmetric tensor of rank 2 for each quadrature point on all cells (or, since we compute in parallel, all quadrature points of all cells that the present MPI process “owns”). At the end of each time step we then only have to evaluate , multiply it by the stress-strain tensor , and use the result to update the stress at quadrature point .
/usr/share/doc/packages/dealii/doxygen/deal.II/step_19.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_19.html 2024-12-27 18:25:18.580940866 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_19.html 2024-12-27 18:25:18.584940893 +0000
@@ -161,135 +161,135 @@
The finite element method in general, and deal.II in particular, were invented to solve partial differential equations – in other words, to solve continuum mechanics problems. On the other hand, sometimes one wants to solve problems in which it is useful to track individual objects ("particles") and how their positions evolve. If this simply leads to a set of ordinary differential equations, for example if you want to track the positions of the planets in the solar system over time, then deal.II is clearly not the right tool. On the other hand, if this evolution is due to the interaction with the solution of partial differential equations, or if having a mesh to determine which particles interact with others (such as in the smoothed particle hydrodynamics (SPH) method), then deal.II has support for you.
The case we will consider here is how electrically charged particles move through an electric field. As motivation, we will consider cathode rays: Electrons emitted by a heated piece of metal that is negatively charged (the "cathode"), and that are then accelerated by an electric field towards the positively charged electrode (the "anode"). The anode is typically ring-shaped so that the majority of electrons can fly through the hole in the form of an electron beam. In the olden times, they might then have illuminated the screen of a TV built from a cathode ray tube. Today, instead, electron beams are useful in X-ray machines, electron beam lithography, electron beam welding, and a number of other areas.
The equations we will then consider are as follows: First, we need to describe the electric field. This is most easily accomplished by noting that the electric potential satisfied the equation
-
+\]" src="form_3134.png"/>
-
where is the dielectric constant of vacuum, and is the charge density. This is augmented by boundary conditions that we will choose as follows:
- is the dielectric constant of vacuum, and is the charge density. This is augmented by boundary conditions that we will choose as follows:
+
+\end{align*}" src="form_3136.png"/>
-
In other words, we prescribe voltages and at the two electrodes and insulating (Neumann) boundary conditions elsewhere. Since the dynamics of the particles are purely due to the electric field , we could as well have prescribed and at the two electrodes – all that matters is the voltage difference at the two electrodes.
-
Given this electric potential and the electric field , we can describe the trajectory of the th particle using the differential equation
- and at the two electrodes and insulating (Neumann) boundary conditions elsewhere. Since the dynamics of the particles are purely due to the electric field , we could as well have prescribed and at the two electrodes – all that matters is the voltage difference at the two electrodes.
+
Given this electric potential and the electric field , we can describe the trajectory of the th particle using the differential equation
+
+\]" src="form_3141.png"/>
-
where are the mass and electric charge of each particle. In practice, it is convenient to write this as a system of first-order differential equations in the position and velocity :
- are the mass and electric charge of each particle. In practice, it is convenient to write this as a system of first-order differential equations in the position and velocity :
+
+\end{align*}" src="form_3143.png"/>
-
The deal.II class we will use to deal with particles, Particles::ParticleHandler, stores particles in a way so that the position is part of the Particles::ParticleHandler data structures. (It stores particles sorted by cell they are in, and consequently needs to know where each particle is.) The velocity , on the other hand, is of no concern to Particles::ParticleHandler and consequently we will store it as a "property" of each particle that we will update in each time step. Properties can also be used to store any other quantity we might care about each particle: its charge, or if they were larger than just an electron, its color, mass, attitude in space, chemical composition, etc.
+
The deal.II class we will use to deal with particles, Particles::ParticleHandler, stores particles in a way so that the position is part of the Particles::ParticleHandler data structures. (It stores particles sorted by cell they are in, and consequently needs to know where each particle is.) The velocity , on the other hand, is of no concern to Particles::ParticleHandler and consequently we will store it as a "property" of each particle that we will update in each time step. Properties can also be used to store any other quantity we might care about each particle: its charge, or if they were larger than just an electron, its color, mass, attitude in space, chemical composition, etc.
There remain two things to discuss to complete the model: Where particles start and what the charge density is.
-
First, historically, cathode rays used very large electric fields to pull electrons out of the metal. This produces only a relatively small current. One can do better by heating the cathode: a statistical fraction of electrons in that case have enough thermal energy to leave the metal; the electric field then just has to be strong enough to pull them away from the attraction of their host body. We will model this in the following way: We will create a new particle if (i) the electric field points away from the electrode, i.e., if where is the normal vector at a face pointing out of the domain (into the electrode), and (ii) the electric field exceeds a threshold value . This is surely not a sufficiently accurate model for what really happens, but is good enough for our current tutorial program.
+
First, historically, cathode rays used very large electric fields to pull electrons out of the metal. This produces only a relatively small current. One can do better by heating the cathode: a statistical fraction of electrons in that case have enough thermal energy to leave the metal; the electric field then just has to be strong enough to pull them away from the attraction of their host body. We will model this in the following way: We will create a new particle if (i) the electric field points away from the electrode, i.e., if where is the normal vector at a face pointing out of the domain (into the electrode), and (ii) the electric field exceeds a threshold value . This is surely not a sufficiently accurate model for what really happens, but is good enough for our current tutorial program.
Second, in principle we would have to model the charge density via
-
+\]" src="form_3148.png"/>
-
The issue now is that in reality, a cathode ray tube in an old television yields a current of somewhere around a few milli-Amperes. In the much higher energy beams of particle accelerators, the current may only be a few nano-Ampere. But an Ampere is electrons flowing per second. Now, as you will see in the results section, we really only simulate a few microseconds ( seconds), but that still results in very very large numbers of electrons – far more than we can hope to simulate with a program as small as the current one. As a consequence, let us presume that each particle represents electrons. Then the particle mass and charge are also and and the equations we have to solve are
- electrons flowing per second. Now, as you will see in the results section, we really only simulate a few microseconds ( seconds), but that still results in very very large numbers of electrons – far more than we can hope to simulate with a program as small as the current one. As a consequence, let us presume that each particle represents electrons. Then the particle mass and charge are also and and the equations we have to solve are
+
+\]" src="form_3152.png"/>
-
which is of course exactly the same as above after dividing both sides by . On the other hand, the charge density for these "clumps" of electrons is given by
-. On the other hand, the charge density for these "clumps" of electrons is given by
+
+\]" src="form_3153.png"/>
-
It is this form that we will implement in the program, where is chosen rather large in the program to ensure that the particles actually affect the electric field. (This may not be realistic in practice: In most cases, there are just not enough electrons to actually affect the overall electric field. But realism is not our goal here.)
-
As a final thought about the model, one may wonder why the equation for the electric field (or, rather, the electric potential) has no time derivative whereas the equations for the electron positions do. In essence, this is a modeling assumption: We assume that the particles move so slowly that at any given time the electric field is in equilibrium. This is saying, in other words, that the velocity of the electrons is much less than the speed of light. In yet other words, we can rephrase this in terms of the electrode voltage : Since every volt of electric potential accelerates electrons by approximately 600 km/s (neglecting relativistic effects), requiring is equivalent to saying that . Under this assumption (and the assumption that the total number of electrons is small), one can also neglect the creation of magnetic fields by the moving charges, which would otherwise also affect the movement of the electrons.
+
It is this form that we will implement in the program, where is chosen rather large in the program to ensure that the particles actually affect the electric field. (This may not be realistic in practice: In most cases, there are just not enough electrons to actually affect the overall electric field. But realism is not our goal here.)
+
As a final thought about the model, one may wonder why the equation for the electric field (or, rather, the electric potential) has no time derivative whereas the equations for the electron positions do. In essence, this is a modeling assumption: We assume that the particles move so slowly that at any given time the electric field is in equilibrium. This is saying, in other words, that the velocity of the electrons is much less than the speed of light. In yet other words, we can rephrase this in terms of the electrode voltage : Since every volt of electric potential accelerates electrons by approximately 600 km/s (neglecting relativistic effects), requiring is equivalent to saying that . Under this assumption (and the assumption that the total number of electrons is small), one can also neglect the creation of magnetic fields by the moving charges, which would otherwise also affect the movement of the electrons.
Time discretization
The equations outlined above then form a set of coupled differential equations. Let us bring them all together in one place again to make that clear:
-
+\end{align*}" src="form_3157.png"/>
Because of the awkward dependence of the electric potential on the particle locations, we don't want to solve this as a coupled system but instead use a decoupled approach where we first solve for the potential in each time step and then the particle locations. (One could also do it the other way around, of course.) This is very much in the same spirit as we do in step-21, step-31, and step-32, to name just a few, and can all be understood in the context of the operator splitting methods discussed in step-58.
-
So, if we denote by an upper index the time step, and if we use a simple time discretization for the ODE, then this means that we have to solve the following set of equations in each time step:
- the time step, and if we use a simple time discretization for the ODE, then this means that we have to solve the following set of equations in each time step:
+
+\end{align*}" src="form_3158.png"/>
-
This scheme can be understood in the framework of operator splitting methods (specifically, the "Lie splitting" method) wherein a coupled system is solved by updating one variable at a time, using either the old values of other variables (e.g., using in the first equation) or the values of variables that have already been updated in a previous sub-step (e.g., using in the second equation). There are of course many better ways to do a time discretization (for example the simple leapfrog scheme when updating the velocity, or more general Strang splitting methods for the coupled system) but this isn't the point of the tutorial program, and so we will be content with what we have here. (We will comment on a piece of this puzzle in the possibilities for extensions section of this program, however.)
+
This scheme can be understood in the framework of operator splitting methods (specifically, the "Lie splitting" method) wherein a coupled system is solved by updating one variable at a time, using either the old values of other variables (e.g., using in the first equation) or the values of variables that have already been updated in a previous sub-step (e.g., using in the second equation). There are of course many better ways to do a time discretization (for example the simple leapfrog scheme when updating the velocity, or more general Strang splitting methods for the coupled system) but this isn't the point of the tutorial program, and so we will be content with what we have here. (We will comment on a piece of this puzzle in the possibilities for extensions section of this program, however.)
There remains the question of how we should choose the time step size . The limitation here is that the Particles::ParticleHandler class needs to keep track of which cell each particle is in. This is particularly an issue if we are running computations in parallel (say, in step-70) because in that case every process only stores those cells it owns plus one layer of "ghost cells". That's not relevant here, but in general we should make sure that over the course of each time step, a particle moves only from one cell to any of its immediate neighbors (face, edge, or vertex neighbors). If we can ensure that, then Particles::ParticleHandler is guaranteed to be able to figure out which cell a particle ends up in. To do this, a useful rule of thumb is that we should choose the time step so that for all particles the expected distance the particle moves by is less than one cell diameter:
-
+\]" src="form_3161.png"/>
or equivalently
-
+\]" src="form_3162.png"/>
-
Here, is the length of the shortest edge of the cell on which particle is located – in essence, a measure of the size of a cell.
+
Here, is the length of the shortest edge of the cell on which particle is located – in essence, a measure of the size of a cell.
On the other hand, a particle might already be at the boundary of one cell and the neighboring cell might be once further refined. So then the time to cross that neighboring cell would actually be half the amount above, suggesting
-
+\]" src="form_3163.png"/>
But even that is not good enough: The formula above updates the particle positions in each time using the formula
-
+\]" src="form_3164.png"/>
-
that is, using the current velocity . But we don't have the current velocity yet at the time when we need to choose – which is after we have updated the potential but before we update the velocity from to . All we have is . So we need an additional safety factor for our final choice:
-. But we don't have the current velocity yet at the time when we need to choose – which is after we have updated the potential but before we update the velocity from to . All we have is . So we need an additional safety factor for our final choice:
+
+\]" src="form_3168.png"/>
-
How large should be? That depends on how much of underestimate might be compared to , and that is actually quite easy to assess: A particle created in one time step with zero velocity will roughly pick up equal velocity increments in each successive time step if the electric field it encounters along the way were roughly constant. So the maximal difference between and would be a factor of two. As a consequence, we will choose .
+
How large should be? That depends on how much of underestimate might be compared to , and that is actually quite easy to assess: A particle created in one time step with zero velocity will roughly pick up equal velocity increments in each successive time step if the electric field it encounters along the way were roughly constant. So the maximal difference between and would be a factor of two. As a consequence, we will choose .
There is only one other case we ought to consider: What happens in the very first time step? There, any particles to be moved along have just been created, but they have a zero velocity. So we don't know what velocity we should choose for them. Of course, in all other time steps there are also particles that have just been created, but in general, the particles with the highest velocity limit the time step size and so the newly created particles with their zero velocity don't matter. But if we only have such particles?
-
In that case, we can use the following approximation: If a particle starts at , then the update formula tells us that
-, then the update formula tells us that
+
+\]" src="form_3174.png"/>
and consequently
-
+\]" src="form_3175.png"/>
which we can write as
-
+\]" src="form_3176.png"/>
-
Not wanting to move a particle by more than then implies that we should choose the time step as
- then implies that we should choose the time step as
+
+\]" src="form_3178.png"/>
Using the same argument about neighboring cells possibly being smaller by a factor of two then leads to the final formula for time step zero:
-
+\]" src="form_3179.png"/>
-
Strictly speaking, we would have to evaluate the electric potential at the location of each particle, but a good enough approximation is to use the maximum of the values at the vertices of the respective cell. (Why the vertices and not the midpoint? Because the gradient of the solution of the Laplace equation, i.e., the electric field, is largest in corner singularities which are located at the vertices of cells.) This has the advantage that we can make good use of the FEValues functionality which can recycle pre-computed material as long as the quadrature points are the same from one cell to the next.
-
We could always run this kind of scheme to estimate the difference between and , but it relies on evaluating the electric field on each cell, and that is expensive. As a consequence, we will limit this approach to the very first time step.
+
Strictly speaking, we would have to evaluate the electric potential at the location of each particle, but a good enough approximation is to use the maximum of the values at the vertices of the respective cell. (Why the vertices and not the midpoint? Because the gradient of the solution of the Laplace equation, i.e., the electric field, is largest in corner singularities which are located at the vertices of cells.) This has the advantage that we can make good use of the FEValues functionality which can recycle pre-computed material as long as the quadrature points are the same from one cell to the next.
+
We could always run this kind of scheme to estimate the difference between and , but it relies on evaluating the electric field on each cell, and that is expensive. As a consequence, we will limit this approach to the very first time step.
Spatial discretization
-
Having discussed the time discretization, the discussion of the spatial discretization is going to be short: We use quadratic finite elements, i.e., the space , to approximate the electric potential . The mesh is adapted a couple of times during the initial time step. All of this is entirely standard if you have read step-6, and the implementation does not provide for any kind of surprise.
+
Having discussed the time discretization, the discussion of the spatial discretization is going to be short: We use quadratic finite elements, i.e., the space , to approximate the electric potential . The mesh is adapted a couple of times during the initial time step. All of this is entirely standard if you have read step-6, and the implementation does not provide for any kind of surprise.
Dealing with particles programmatically
Adding and moving particles is, in practice, not very difficult in deal.II. To add one, the create_particles() function of this program simply uses a code snippet of the following form:
/usr/share/doc/packages/dealii/doxygen/deal.II/step_2.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_2.html 2024-12-27 18:25:18.628941196 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_2.html 2024-12-27 18:25:18.628941196 +0000
@@ -132,14 +132,14 @@
Introduction
Note
The material presented here is also discussed in video lecture 9. (All video lectures are also available here.)
-
The finite element method is based on approximating the solution of a differential equation such as by a function that is "piecewise" polynomial; that is, we subdivide the domain on which the equation is posed into small cells that in the documentation we will generally denote by the symbol . On each cell , the approximating function we seek is then a polynomial. (Or, strictly speaking, a function that is the image of a polynomial from a "reference cell", but let us not make things more complicated than necessary for now.)
+
The finite element method is based on approximating the solution of a differential equation such as by a function that is "piecewise" polynomial; that is, we subdivide the domain on which the equation is posed into small cells that in the documentation we will generally denote by the symbol . On each cell , the approximating function we seek is then a polynomial. (Or, strictly speaking, a function that is the image of a polynomial from a "reference cell", but let us not make things more complicated than necessary for now.)
In the previous tutorial program (in step-1), we showed how we should think of the subdivision of the domain into cells as a "mesh" represented by the Triangulation class, and how this looks like in code. In the current tutorial program, we now show how one represents piecewise polynomial functions through the concept of degrees of freedom defined on this mesh. For this example, we will use the lowest order ( ) finite elements, that is the approximating function we are looking for will be "bi-linear" on each quadrilateral cell of the mesh. (They would be linear if we would work on triangles.)
-
In practice, we represent the function as a linear combination of shape functions with multipliers that we call the "degrees of freedom". For the bi-linear functions we consider here, each of these shape functions and degrees of freedom is associated with a vertex of the mesh. Later examples will demonstrate higher order elements where degrees of freedom are not necessarily associated with vertices any more, but can be associated with edges, faces, or cells.
-
The term "degree of freedom" 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 problems 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 is 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.
+
In practice, we represent the function as a linear combination of shape functions with multipliers that we call the "degrees of freedom". For the bi-linear functions we consider here, each of these shape functions and degrees of freedom is associated with a vertex of the mesh. Later examples will demonstrate higher order elements where degrees of freedom are not necessarily associated with vertices any more, but can be associated with edges, faces, or cells.
+
The term "degree of freedom" 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 problems 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 is 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.
Enumerating degrees of freedom
-
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 order elements, one also has to enumerate the shape functions that are associated with edges, faces, or cell interiors of the mesh. In other words, the enumeration of degrees of freedom is an entirely separate thing from the indices we use for vertices. The class that provides this enumeration of the basis functions of is called DoFHandler.
+
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 order elements, one also has to enumerate the shape functions that are associated with edges, faces, or cell interiors of the mesh. In other words, the enumeration of degrees of freedom is an entirely separate thing from the indices we use for vertices. The class that provides this enumeration of the basis functions of is called DoFHandler.
Defining degrees of freedom ("DoF"s in short) on a mesh is, in practice, a rather simple task, since the library does all the work for you. Essentially, all you have to do is create a finite element object (from one of the many finite element classes deal.II already has, see for example the Finite element space descriptions documentation) and give it to a DoFHandler object through the DoFHandler::distribute_dofs() function ("distributing DoFs" is the term we use to describe the process of enumerating the basis functions as discussed above). The DoFHandler is a class that knows which degrees of freedom live where, i.e., it can answer questions like "how many degrees of freedom are there globally" and "on this cell, give me the global indices of the shape functions that
live here". This is the sort of information you need when determining how big your system matrix should be, and when copying the contributions of a single cell into the global matrix.
The first task of the current program is therefore to take a mesh and a finite element, and enumerate the degrees of freedom. In the current context, this means simply giving each vertex of the mesh a DoF index. Once that has happened, we will output in a picture which vertex ended up with which DoF index. You can find the corresponding pictures in the results section of this tutorial.
@@ -148,11 +148,11 @@
The next step would then be to compute a matrix and right hand side corresponding to a particular differential equation using this finite element and mesh. We will keep this step for the step-3 program and rather talk about one practical aspect of a finite element program, namely that finite element matrices are always very sparse: almost all entries in these matrices are zero.
To be more precise, we say that a matrix is sparse if the number of nonzero entries per row in the matrix is bounded by a number that is independent of the overall number of degrees of freedom. For example, the simple 5-point stencil of a finite difference approximation of the Laplace equation leads to a sparse matrix since the number of nonzero entries per row is five, and therefore independent of the total size of the matrix. For more complicated problems – say, the Stokes problem of step-22 – and in particular in 3d, the number of entries per row may be several hundred. But the important point is that this number is independent of the overall size of the problem: If you refine the mesh, the maximal number of unknowns per row remains the same.
Sparsity is one of the distinguishing features of the finite element method compared to, say, approximating the solution of a partial differential equation using a Taylor expansion and matching coefficients, or using a Fourier basis.
-
In practical terms, it is the sparsity of matrices that enables us to solve problems with millions or billions of unknowns. To understand this, note that a matrix with rows, each with a fixed upper bound for the number of nonzero entries, requires memory locations for storage, and a matrix-vector multiplication also requires only operations. Consequently, if we had a linear solver that requires only a fixed number of matrix-vector multiplications to come up with the solution of a linear system with this matrix, then we would have a solver that can find the values of all unknowns with optimal complexity, i.e., with a total of operations. It is clear that this wouldn't be possible if the matrix were not sparse (because then the number of entries in the matrix would have to be with some , and doing a fixed number of matrix-vector products would take operations), but it also requires very specialized solvers such as multigrid methods to satisfy the requirement that the solution requires only a fixed number of matrix-vector multiplications. We will frequently look at the question of what solver to use in the remaining programs of this tutorial.
-
The sparsity is generated by the fact that finite element shape functions are defined locally on individual cells, rather than globally, and that the local differential operators in the bilinear form only couple shape functions whose support overlaps. (The "support" of a function is the area where it is nonzero. For the finite element method, the support of a shape function is generally the cells adjacent to the vertex, edge, or face it is defined on.) In other words, degrees of freedom and that are not defined on the same cell do not overlap, and consequently the matrix entry will be zero. (In some cases such as the Discontinuous Galerkin method, shape functions may also connect to neighboring cells through face integrals. But finite element methods do not generally couple shape functions beyond the immediate neighbors of a cell on which the function is defined.)
+
In practical terms, it is the sparsity of matrices that enables us to solve problems with millions or billions of unknowns. To understand this, note that a matrix with rows, each with a fixed upper bound for the number of nonzero entries, requires memory locations for storage, and a matrix-vector multiplication also requires only operations. Consequently, if we had a linear solver that requires only a fixed number of matrix-vector multiplications to come up with the solution of a linear system with this matrix, then we would have a solver that can find the values of all unknowns with optimal complexity, i.e., with a total of operations. It is clear that this wouldn't be possible if the matrix were not sparse (because then the number of entries in the matrix would have to be with some , and doing a fixed number of matrix-vector products would take operations), but it also requires very specialized solvers such as multigrid methods to satisfy the requirement that the solution requires only a fixed number of matrix-vector multiplications. We will frequently look at the question of what solver to use in the remaining programs of this tutorial.
+
The sparsity is generated by the fact that finite element shape functions are defined locally on individual cells, rather than globally, and that the local differential operators in the bilinear form only couple shape functions whose support overlaps. (The "support" of a function is the area where it is nonzero. For the finite element method, the support of a shape function is generally the cells adjacent to the vertex, edge, or face it is defined on.) In other words, degrees of freedom and that are not defined on the same cell do not overlap, and consequently the matrix entry will be zero. (In some cases such as the Discontinuous Galerkin method, shape functions may also connect to neighboring cells through face integrals. But finite element methods do not generally couple shape functions beyond the immediate neighbors of a cell on which the function is defined.)
How degrees of freedom are enumerated
By default, the DoFHandler class enumerates degrees of freedom on a mesh using an algorithm that is difficult to describe and leads to results that do look right if you know what it is doing but otherwise appears rather random; consequently, the sparsity pattern is also not optimized for any particular purpose. To show this, the code below will demonstrate a simple way to output the "sparsity pattern" that corresponds to a DoFHandler, i.e., an object that represents all of the potentially nonzero elements of a matrix one may build when discretizing a partial differential equation on a mesh and its DoFHandler. This lack of structure in the sparsity pattern will be apparent from the pictures we show below.
-
For most applications and algorithms, the exact way in which degrees of freedom are numbered does not matter. For example, the Conjugate Gradient method we use to solve linear systems does not care. On the other hand, some algorithms do care: in particular, some preconditioners such as SSOR will work better if they can walk through degrees of freedom in a particular order, and it would be nice if we could just sort them in such a way that SSOR can iterate through them from zero to in this order. Other examples include computing incomplete LU or Cholesky factorizations, or if we care about the block structure of matrices (see step-20 for an example). deal.II therefore has algorithms that can re-enumerate degrees of freedom in particular ways in namespace DoFRenumbering. Renumbering can be thought of as choosing a different, permuted basis of the finite element space. The sparsity pattern and matrices that result from this renumbering are therefore also simply a permutation of rows and columns compared to the ones we would get without explicit renumbering.
+
For most applications and algorithms, the exact way in which degrees of freedom are numbered does not matter. For example, the Conjugate Gradient method we use to solve linear systems does not care. On the other hand, some algorithms do care: in particular, some preconditioners such as SSOR will work better if they can walk through degrees of freedom in a particular order, and it would be nice if we could just sort them in such a way that SSOR can iterate through them from zero to in this order. Other examples include computing incomplete LU or Cholesky factorizations, or if we care about the block structure of matrices (see step-20 for an example). deal.II therefore has algorithms that can re-enumerate degrees of freedom in particular ways in namespace DoFRenumbering. Renumbering can be thought of as choosing a different, permuted basis of the finite element space. The sparsity pattern and matrices that result from this renumbering are therefore also simply a permutation of rows and columns compared to the ones we would get without explicit renumbering.
In the program below, we will use the algorithm of Cuthill and McKee to do so. We will show the sparsity pattern for both the original enumeration of degrees of freedom and of the renumbered version below, in the results section.
The commented program
The first few includes are just like in the previous program, so do not require additional comments:
@@ -288,7 +288,7 @@
Â
Renumbering of DoFs
In the sparsity pattern produced above, the nonzero entries extended quite far off from the diagonal. For some algorithms, for example for incomplete LU decompositions or Gauss-Seidel preconditioners, this is unfavorable, and we will show a simple way how to improve this situation.
-
Remember that for an entry in the matrix to be nonzero, the supports of the shape functions i and j needed to intersect (otherwise in the integral, the integrand would be zero everywhere since either the one or the other shape function is zero at some point). However, the supports of shape functions intersected only if they were adjacent to each other, so in order to have the nonzero entries clustered around the diagonal (where equals ), we would like to have adjacent shape functions to be numbered with indices (DoF numbers) that differ not too much.
+
Remember that for an entry in the matrix to be nonzero, the supports of the shape functions i and j needed to intersect (otherwise in the integral, the integrand would be zero everywhere since either the one or the other shape function is zero at some point). However, the supports of shape functions intersected only if they were adjacent to each other, so in order to have the nonzero entries clustered around the diagonal (where equals ), we would like to have adjacent shape functions to be numbered with indices (DoF numbers) that differ not too much.
This can be accomplished by a simple front marching algorithm, where one starts at a given vertex and gives it the index zero. Then, its neighbors are numbered successively, making their indices close to the original one. Then, their neighbors, if not yet numbered, are numbered, and so on.
One algorithm that adds a little bit of sophistication along these lines is the one by Cuthill and McKee. We will use it in the following function to renumber the degrees of freedom such that the resulting sparsity pattern is more localized around the diagonal. The only interesting part of the function is the first call to DoFRenumbering::Cuthill_McKee, the rest is essentially as before:
/usr/share/doc/packages/dealii/doxygen/deal.II/step_20.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_20.html 2024-12-27 18:25:18.700941690 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_20.html 2024-12-27 18:25:18.704941717 +0000
@@ -167,13 +167,13 @@
p &=& g \qquad {\textrm{on}\ }\partial\Omega.
\end{eqnarray*}" src="form_3206.png"/>
-
is assumed to be uniformly positive definite, i.e., there is such that the eigenvalues of satisfy . The use of the symbol instead of the usual for the solution variable will become clear in the next section.
+
is assumed to be uniformly positive definite, i.e., there is such that the eigenvalues of satisfy . The use of the symbol instead of the usual for the solution variable will become clear in the next section.
After discussing the equation and the formulation we are going to use to solve it, this introduction will cover the use of block matrices and vectors, the definition of solvers and preconditioners, and finally the actual test case we are going to solve.
We are going to extend this tutorial program in step-21 to solve not only the mixed Laplace equation, but add another equation that describes the transport of a mixture of two fluids.
The equations covered here fall into the class of vector-valued problems. A toplevel overview of this topic can be found in the Handling vector valued problems topic.
The equations
In the form above, the Poisson equation (i.e., the Laplace equation with a nonzero right hand side) is generally considered a good model equation for fluid flow in porous media. Of course, one typically models fluid flow through the Navier-Stokes equations or, if fluid velocities are slow or the viscosity is large, the Stokes equations (which we cover in step-22). In the first of these two models, the forces that act are inertia and viscous friction, whereas in the second it is only viscous friction – i.e., forces that one fluid particle exerts on a nearby one. This is appropriate if you have free flow in a large domain, say a pipe, a river, or in the air. On the other hand, if the fluid is confined in pores, then friction forces exerted by the pore walls on the fluid become more and more important and internal viscous friction becomes less and less important. Modeling this then first leads to the Brinkman model if both effects are important, and in the limit of very small pores to the Darcy equations. The latter is just a different name for the Poisson or Laplace equation, connotating it with the area to which one wants to apply it: slow flow in a porous medium. In essence it says that the velocity is proportional to the negative pressure gradient that drives the fluid through the porous medium.
-
The Darcy equation models this pressure that drives the flow. (Because the solution variable is a pressure, we here use the name instead of the name more commonly used for the solution of partial differential equations.) Typical applications of this view of the Laplace equation are then modeling groundwater flow, or the flow of hydrocarbons in oil reservoirs. In these applications, is the permeability tensor, i.e., a measure for how much resistance the soil or rock matrix asserts on the fluid flow.
+
The Darcy equation models this pressure that drives the flow. (Because the solution variable is a pressure, we here use the name instead of the name more commonly used for the solution of partial differential equations.) Typical applications of this view of the Laplace equation are then modeling groundwater flow, or the flow of hydrocarbons in oil reservoirs. In these applications, is the permeability tensor, i.e., a measure for how much resistance the soil or rock matrix asserts on the fluid flow.
In the applications named above, a desirable feature for a numerical scheme is that it should be locally conservative, i.e., that whatever flows into a cell also flows out of it (or the difference is equal to the integral over the source terms over each cell, if the sources are nonzero). However, as it turns out, the usual discretizations of the Laplace equation (such as those used in step-3, step-4, or step-6) do not satisfy this property. But, one can achieve this by choosing a different formulation of the problem and a particular combination of finite element spaces.
Formulation, weak form, and discrete problem
To this end, one first introduces a second variable, called the velocity, . By its definition, the velocity is a vector in the negative direction of the pressure gradient, multiplied by the permeability tensor. If the permeability tensor is proportional to the unit matrix, this equation is easy to understand and intuitive: the higher the permeability, the higher the velocity; and the velocity is proportional to the gradient of the pressure, going from areas of high pressure to areas of low pressure (thus the negative sign).
Here, is the outward normal vector at the boundary. Note how in this formulation, Dirichlet boundary values of the original problem are incorporated in the weak form.
-
To be well-posed, we have to look for solutions and test functions in the space for , , and for . It is a well-known fact stated in almost every book on finite element theory that if one chooses discrete finite element spaces for the approximation of inappropriately, then the resulting discrete problem is instable and the discrete solution will not converge to the exact solution. (Some details on the problem considered here – which falls in the class of "saddle-point problems" – can be found on the Wikipedia page on the Ladyzhenskaya-Babuska-Brezzi (LBB) condition.)
-
To overcome this, a number of different finite element pairs for have been developed that lead to a stable discrete problem. One such pair is to use the Raviart-Thomas spaces for the velocity and discontinuous elements of class for the pressure . For details about these spaces, we refer in particular to the book on mixed finite element methods by Brezzi and Fortin, but many other books on the theory of finite elements, for example the classic book by Brenner and Scott, also state the relevant results. In any case, with appropriate choices of function spaces, the discrete formulation reads as follows: Find for , , and for . It is a well-known fact stated in almost every book on finite element theory that if one chooses discrete finite element spaces for the approximation of inappropriately, then the resulting discrete problem is instable and the discrete solution will not converge to the exact solution. (Some details on the problem considered here – which falls in the class of "saddle-point problems" – can be found on the Wikipedia page on the Ladyzhenskaya-Babuska-Brezzi (LBB) condition.)
+
To overcome this, a number of different finite element pairs for have been developed that lead to a stable discrete problem. One such pair is to use the Raviart-Thomas spaces for the velocity and discontinuous elements of class for the pressure . For details about these spaces, we refer in particular to the book on mixed finite element methods by Brezzi and Fortin, but many other books on the theory of finite elements, for example the classic book by Brenner and Scott, also state the relevant results. In any case, with appropriate choices of function spaces, the discrete formulation reads as follows: Find so that
-
Before continuing, let us briefly pause and show that the choice of function spaces above provides us with the desired local conservation property. In particular, because the pressure space consists of discontinuous piecewise polynomials, we can choose the test function as the function that is equal to one on any given cell and zero everywhere else. If we also choose everywhere (remember that the weak form above has to hold for all discrete test functions ), then putting these choices of test functions into the weak formulation above implies in particular that
+
Before continuing, let us briefly pause and show that the choice of function spaces above provides us with the desired local conservation property. In particular, because the pressure space consists of discontinuous piecewise polynomials, we can choose the test function as the function that is equal to one on any given cell and zero everywhere else. If we also choose everywhere (remember that the weak form above has to hold for all discrete test functions ), then putting these choices of test functions into the weak formulation above implies in particular that
If you now recall that was the velocity, then the integral on the left is exactly the (discrete) flux across the boundary of the cell . The statement is then that the flux must be equal to the integral over the sources within . In particular, if there are no sources (i.e., in ), then the statement is that total flux is zero, i.e., whatever flows into a cell must flow out of it through some other part of the cell boundary. This is what we call local conservation because it holds for every cell.
-
On the other hand, the usual continuous elements would not result in this kind of property when used for the pressure (as, for example, we do in step-43) because one can not choose a discrete test function that is one on a cell and zero everywhere else: It would be discontinuous and consequently not in the finite element space. (Strictly speaking, all we can say is that the proof above would not work for continuous elements. Whether these elements might still result in local conservation is a different question as one could think that a different kind of proof might still work; in reality, however, the property really does not hold.)
+
On the other hand, the usual continuous elements would not result in this kind of property when used for the pressure (as, for example, we do in step-43) because one can not choose a discrete test function that is one on a cell and zero everywhere else: It would be discontinuous and consequently not in the finite element space. (Strictly speaking, all we can say is that the proof above would not work for continuous elements. Whether these elements might still result in local conservation is a different question as one could think that a different kind of proof might still work; in reality, however, the property really does not hold.)
Assembling the linear system
The deal.II library (of course) implements Raviart-Thomas elements of arbitrary order , as well as discontinuous elements . If we forget about their particular properties for a second, we then have to solve a discrete problem
with the bilinear form and right hand side as stated above, and , . Both and are from the space , where is itself a space of -dimensional functions to accommodate for the fact that the flow velocity is vector-valued. The necessary question then is: how do we do this in a program?
-
Vector-valued elements have already been discussed in previous tutorial programs, the first time and in detail in step-8. The main difference there was that the vector-valued space is uniform in all its components: the components of the displacement vector are all equal and from the same function space. What we could therefore do was to build as the outer product of the times the usual finite element space, and by this make sure that all our shape functions have only a single non-zero vector component. Instead of dealing with vector-valued shape functions, all we did in step-8 was therefore to look at the (scalar) only non-zero component and use the fe.system_to_component_index(i).first call to figure out which component this actually is.
-
This doesn't work with Raviart-Thomas elements: following from their construction to satisfy certain regularity properties of the space , the shape functions of are usually nonzero in all their vector components at once. For this reason, were fe.system_to_component_index(i).first applied to determine the only nonzero component of shape function , an exception would be generated. What we really need to do is to get at all vector components of a shape function. In deal.II diction, we call such finite elements non-primitive, whereas finite elements that are either scalar or for which every vector-valued shape function is nonzero only in a single vector component are called primitive.
+
Vector-valued elements have already been discussed in previous tutorial programs, the first time and in detail in step-8. The main difference there was that the vector-valued space is uniform in all its components: the components of the displacement vector are all equal and from the same function space. What we could therefore do was to build as the outer product of the times the usual finite element space, and by this make sure that all our shape functions have only a single non-zero vector component. Instead of dealing with vector-valued shape functions, all we did in step-8 was therefore to look at the (scalar) only non-zero component and use the fe.system_to_component_index(i).first call to figure out which component this actually is.
+
This doesn't work with Raviart-Thomas elements: following from their construction to satisfy certain regularity properties of the space , the shape functions of are usually nonzero in all their vector components at once. For this reason, were fe.system_to_component_index(i).first applied to determine the only nonzero component of shape function , an exception would be generated. What we really need to do is to get at all vector components of a shape function. In deal.II diction, we call such finite elements non-primitive, whereas finite elements that are either scalar or for which every vector-valued shape function is nonzero only in a single vector component are called primitive.
So what do we have to do for non-primitive elements? To figure this out, let us go back in the tutorial programs, almost to the very beginnings. There, we learned that we use the FEValues class to determine the values and gradients of shape functions at quadrature points. For example, we would call fe_values.shape_value(i,q_point) to obtain the value of the ith shape function on the quadrature point with number q_point. Later, in step-8 and other tutorial programs, we learned that this function call also works for vector-valued shape functions (of primitive finite elements), and that it returned the value of the only non-zero component of shape function i at quadrature point q_point.
For non-primitive shape functions, this is clearly not going to work: there is no single non-zero vector component of shape function i, and the call to fe_values.shape_value(i,q_point) would consequently not make much sense. However, deal.II offers a second function call, fe_values.shape_value_component(i,q_point,comp) that returns the value of the compth vector component of shape function i at quadrature point q_point, where comp is an index between zero and the number of vector components of the present finite element; for example, the element we will use to describe velocities and pressures is going to have components. It is worth noting that this function call can also be used for primitive shape functions: it will simply return zero for all components except one; for non-primitive shape functions, it will in general return a non-zero value for more than just one component.
We could now attempt to rewrite the bilinear form above in terms of vector components. For example, in 2d, the first term could be rewritten like this (note that ):
@@ -276,7 +276,7 @@
fe_values.shape_value_component(j,q,1)
) *
fe_values.JxW(q);
-
This is, at best, tedious, error prone, and not dimension independent. There are obvious ways to make things dimension independent, but in the end, the code is simply not pretty. What would be much nicer is if we could simply extract the and components of a shape function . In the program we do that in the following way:
+
This is, at best, tedious, error prone, and not dimension independent. There are obvious ways to make things dimension independent, but in the end, the code is simply not pretty. What would be much nicer is if we could simply extract the and components of a shape function . In the program we do that in the following way:
You will find the exact same code as above in the sources for the present program. We will therefore not comment much on it below.
Linear solvers and preconditioners
After assembling the linear system we are faced with the task of solving it. The problem here is that the matrix possesses two undesirable properties:
-
It is indefinite, i.e., it has both positive and negative eigenvalues. We don't want to prove this property here, but note that this is true for all matrices of the form such as the one here where is positive definite.
-
The matrix has a zero block at the bottom right (there is no term in the bilinear form that couples the pressure with the pressure test function ).
+
It is indefinite, i.e., it has both positive and negative eigenvalues. We don't want to prove this property here, but note that this is true for all matrices of the form such as the one here where is positive definite.
+
The matrix has a zero block at the bottom right (there is no term in the bilinear form that couples the pressure with the pressure test function ).
At least it is symmetric, but the first issue above still means that the Conjugate Gradient method is not going to work since it is only applicable to problems in which the matrix is symmetric and positive definite. We would have to resort to other iterative solvers instead, such as MinRes, SymmLQ, or GMRES, that can deal with indefinite systems. However, then the next problem immediately surfaces: Due to the zero block, there are zeros on the diagonal and none of the usual, "simple" preconditioners (Jacobi, SSOR) will work as they require division by diagonal elements.
For the matrix sizes we expect to run with this program, the by far simplest approach would be to just use a direct solver (in particular, the SparseDirectUMFPACK class that is bundled with deal.II). step-29 goes this route and shows that solving any linear system can be done in just 3 or 4 lines of code.
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 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 gradient.
By block elimination, we can then re-order this system in the following way (multiply the first row of the system by and then subtract the second row from it):
-
Here, the matrix (called the Schur complement of ) is obviously symmetric and, owing to the positive definiteness of and the fact that has full column rank, is also positive definite.
-
Consequently, if we could compute , we could apply the Conjugate Gradient method to it. However, computing is expensive because it requires us to compute the inverse of the (possibly large) matrix ; and is in fact also a full matrix because even though is sparse, its inverse will generally be a dense matrix. On the other hand, the CG algorithm doesn't require us to actually have a representation of : It is sufficient to form matrix-vector products with it. We can do so in steps, using the fact that matrix products are associative (i.e., we can set parentheses in such a way that the product is more convenient to compute): To compute , we
+
Here, the matrix (called the Schur complement of ) is obviously symmetric and, owing to the positive definiteness of and the fact that has full column rank, is also positive definite.
+
Consequently, if we could compute , we could apply the Conjugate Gradient method to it. However, computing is expensive because it requires us to compute the inverse of the (possibly large) matrix ; and is in fact also a full matrix because even though is sparse, its inverse will generally be a dense matrix. On the other hand, the CG algorithm doesn't require us to actually have a representation of : It is sufficient to form matrix-vector products with it. We can do so in steps, using the fact that matrix products are associative (i.e., we can set parentheses in such a way that the product is more convenient to compute): To compute , we
compute ;
-solve for , using the CG method applied to the positive definite and symmetric mass matrix ;
+solve for , using the CG method applied to the positive definite and symmetric mass matrix ;
compute to obtain .
Note how we evaluate the expression right to left to avoid matrix-matrix products; this way, all we have to do is evaluate matrix-vector products.
-
In the following, we will then have to come up with ways to represent the matrix so that it can be used in a Conjugate Gradient solver, as well as to define ways in which we can precondition the solution of the linear system involving , and deal with solving linear systems with the matrix (the second step above).
+
In the following, we will then have to come up with ways to represent the matrix so that it can be used in a Conjugate Gradient solver, as well as to define ways in which we can precondition the solution of the linear system involving , and deal with solving linear systems with the matrix (the second step above).
Note
The key point in this consideration is to recognize that to implement an iterative solver such as CG or GMRES, we never actually need the actual elements of a matrix! All that is required is that we can form matrix-vector products. The same is true for preconditioners. In deal.II we encode this requirement by only requiring that matrices and preconditioners given to solver classes have a vmult() member function that does the matrix-vector product. How a class chooses to implement this function is not important to the solver. Consequently, classes can implement it by, for example, doing a sequence of products and linear solves as discussed above.
deal.II includes support for describing such linear operations in a very general way. This is done with the LinearOperator class that, like the MatrixType concept, defines a minimal interface for applying a linear operation to a vector:
Rather than using a SolverControl we use the ReductionControl class here that stops iterations when either an absolute tolerance is reached (for which we choose ) or when the residual is reduced by a certain factor (here, ). In contrast the SolverControl class only checks for absolute tolerances. We have to use ReductionControl in our case to work around a minor issue: The right hand sides that we will feed to op_M_inv are essentially formed by residuals that naturally decrease vastly in norm as the outer iterations progress. This makes control by an absolute tolerance very error prone.
-
We now have a LinearOperatorop_M_inv that we can use to construct more complicated operators such as the Schur complement . Assuming that B is a reference to the upper right block constructing a LinearOperatorop_S is a matter of two lines:
We now have a LinearOperatorop_M_inv that we can use to construct more complicated operators such as the Schur complement . Assuming that B is a reference to the upper right block constructing a LinearOperatorop_S is a matter of two lines:
Here, the multiplication of three LinearOperator objects yields a composite object op_S whose vmult() function first applies , then (i.e. solving an equation with ), and finally to any given input vector. In that sense op_S.vmult() is similar to the following code:
B.vmult (tmp1, src); // multiply with the top right block: B
+
Here, the multiplication of three LinearOperator objects yields a composite object op_S whose vmult() function first applies , then (i.e. solving an equation with ), and finally to any given input vector. In that sense op_S.vmult() is similar to the following code:
B.vmult (tmp1, src); // multiply with the top right block: B
solver_M(M, tmp2, tmp1, preconditioner_M); // multiply with M^-1
B.Tvmult (dst, tmp2); // multiply with the bottom left block: B^T
(tmp1 and tmp2 are two temporary vectors). The key point behind this approach is the fact that we never actually create an inner product of matrices. Instead, whenever we have to perform a matrix vector multiplication with op_S we simply run all individual vmult operations in above sequence.
Even though both approaches are exactly equivalent, the LinearOperator class has a big advantage over this manual approach. It provides so-called syntactic sugar: Mathematically, we think about as being the composite matrix and the LinearOperator class allows you to write this out more or less verbatim,
Even though both approaches are exactly equivalent, the LinearOperator class has a big advantage over this manual approach. It provides so-called syntactic sugar: Mathematically, we think about as being the composite matrix and the LinearOperator class allows you to write this out more or less verbatim,
The manual approach on the other hand obscures this fact.
-
All that is left for us to do now is to form the right hand sides of the two equations defining and , and then solve them with the Schur complement matrix and the mass matrix, respectively. For example the right hand side of the first equation reads . This could be implemented as follows:
All that is left for us to do now is to form the right hand sides of the two equations defining and , and then solve them with the Schur complement matrix and the mass matrix, respectively. For example the right hand side of the first equation reads . This could be implemented as follows:
The class allows lazy evaluation of expressions involving vectors and linear operators. This is done by storing the computational expression and only performing the computation when either the object is converted to a vector object, or PackagedOperation::apply() (or PackagedOperation::apply_add()) is invoked by hand. Assuming that F and G are the two vectors of the right hand side we can simply write:
One may ask whether it would help if we had a preconditioner for the Schur complement . The general answer, as usual, is: of course. The problem is only, we don't know anything about this Schur complement matrix. We do not know its entries, all we know is its action. On the other hand, we have to realize that our solver is expensive since in each iteration we have to do one matrix-vector product with the Schur complement, which means that we have to do invert the mass matrix once in each iteration.
-
There are different approaches to preconditioning such a matrix. On the one extreme is to use something that is cheap to apply and therefore has no real impact on the work done in each iteration. The other extreme is a preconditioner that is itself very expensive, but in return really brings down the number of iterations required to solve with .
+
There are different approaches to preconditioning such a matrix. On the one extreme is to use something that is cheap to apply and therefore has no real impact on the work done in each iteration. The other extreme is a preconditioner that is itself very expensive, but in return really brings down the number of iterations required to solve with .
We will try something along the second approach, as much to improve the performance of the program as to demonstrate some techniques. To this end, let us recall that the ideal preconditioner is, of course, , but that is unattainable. However, how about
-
as a preconditioner? That would mean that every time we have to do one preconditioning step, we actually have to solve with . At first, this looks almost as expensive as solving with right away. However, note that in the inner iteration, we do not have to calculate , but only the inverse of its diagonal, which is cheap.
-
Thankfully, the LinearOperator framework makes this very easy to write out. We already used a Jacobi preconditioner (preconditioner_M) for the matrix earlier. So all that is left to do is to write out how the approximate Schur complement should look like:
constauto op_aS =
+
as a preconditioner? That would mean that every time we have to do one preconditioning step, we actually have to solve with . At first, this looks almost as expensive as solving with right away. However, note that in the inner iteration, we do not have to calculate , but only the inverse of its diagonal, which is cheap.
+
Thankfully, the LinearOperator framework makes this very easy to write out. We already used a Jacobi preconditioner (preconditioner_M) for the matrix earlier. So all that is left to do is to write out how the approximate Schur complement should look like:
Note how this operator differs in simply doing one Jacobi sweep (i.e. multiplying with the inverses of the diagonal) instead of multiplying with the full . (This is how a single Jacobi preconditioner step with is defined: it is the multiplication with the inverse of the diagonal of ; in other words, the operation on a vector is exactly what PreconditionJacobi does.)
+
Note how this operator differs in simply doing one Jacobi sweep (i.e. multiplying with the inverses of the diagonal) instead of multiplying with the full . (This is how a single Jacobi preconditioner step with is defined: it is the multiplication with the inverse of the diagonal of ; in other words, the operation on a vector is exactly what PreconditionJacobi does.)
With all this we almost have the preconditioner completed: it should be the inverse of the approximate Schur complement. We implement this again by creating a linear operator with inverse_operator() function. This time however we would like to choose a relatively modest tolerance for the CG solver (that inverts op_aS). The reasoning is that op_aS is only coarse approximation to op_S, so we actually do not need to invert it exactly. This, however creates a subtle problem: preconditioner_S will be used in the final outer CG iteration to create an orthogonal basis. But for this to work, it must be precisely the same linear operation for every invocation. We ensure this by using an IterationNumberControl that allows us to fix the number of CG iterations that are performed to a fixed small number (in our case 30):
The next thing is that we want to figure out the sizes of these blocks so that we can allocate an appropriate amount of space. To this end, we call the DoFTools::count_dofs_per_fe_component() function that counts how many shape functions are non-zero for a particular vector component. We have dim+1 vector components, and DoFTools::count_dofs_per_fe_component() will count how many shape functions belong to each of these components.
-
There is one problem here. As described in the documentation of that function, it wants to put the number of -velocity shape functions into dofs_per_component[0], the number of -velocity shape functions into dofs_per_component[1] (and similar in 3d), and the number of pressure shape functions into dofs_per_component[dim]. But, the Raviart-Thomas element is special in that it is non-primitive, i.e., for Raviart-Thomas elements all velocity shape functions are nonzero in all components. In other words, the function cannot distinguish between and velocity functions because there is no such distinction. It therefore puts the overall number of velocity into each of dofs_per_component[c], . On the other hand, the number of pressure variables equals the number of shape functions that are nonzero in the dim-th component.
+
There is one problem here. As described in the documentation of that function, it wants to put the number of -velocity shape functions into dofs_per_component[0], the number of -velocity shape functions into dofs_per_component[1] (and similar in 3d), and the number of pressure shape functions into dofs_per_component[dim]. But, the Raviart-Thomas element is special in that it is non-primitive, i.e., for Raviart-Thomas elements all velocity shape functions are nonzero in all components. In other words, the function cannot distinguish between and velocity functions because there is no such distinction. It therefore puts the overall number of velocity into each of dofs_per_component[c], . On the other hand, the number of pressure variables equals the number of shape functions that are nonzero in the dim-th component.
Using this knowledge, we can get the number of velocity shape functions from any of the first dim elements of dofs_per_component, and then use this below to initialize the vector and matrix block sizes, as well as create output.
Note
If you find this concept difficult to understand, you may want to consider using the function DoFTools::count_dofs_per_fe_block() instead, as we do in the corresponding piece of code in step-22. You might also want to read up on the difference between blocks and components in the glossary.
 const std::vector<types::global_dof_index> dofs_per_component =
@@ -1084,7 +1084,7 @@
 }
Results
Output of the program and graphical visualization
-
If we run the program as is, we get this output for the mesh we use (for a total of 1024 cells with 1024 pressure degrees of freedom since we use piecewise constants, and 2112 velocities because the Raviart-Thomas element defines one degree per freedom per face and there are faces parallel to the -axis and the same number parallel to the -axis):
\$ make run
+
If we run the program as is, we get this output for the mesh we use (for a total of 1024 cells with 1024 pressure degrees of freedom since we use piecewise constants, and 2112 velocities because the Raviart-Thomas element defines one degree per freedom per face and there are faces parallel to the -axis and the same number parallel to the -axis):
\$ make run
[ 66%] Built target step-20
Scanning dependencies of target run
[100%] Run step-20 with Release configuration
@@ -1103,7 +1103,7 @@
As an additional remark, note how the x-velocity in the left image is only continuous in x-direction, whereas the y-velocity is continuous in y-direction. The flow fields are discontinuous in the other directions. This very obviously reflects the continuity properties of the Raviart-Thomas elements, which are, in fact, only in the space H(div) and not in the space . Finally, the pressure field is completely discontinuous, but that should not surprise given that we have chosen FE_DGQ(0) as the finite element for that solution component.
Convergence
The program offers two obvious places where playing and observing convergence is in order: the degree of the finite elements used (passed to the constructor of the MixedLaplaceProblem class from main()), and the refinement level (determined in MixedLaplaceProblem::make_grid_and_dofs). What one can do is to change these values and observe the errors computed later on in the course of the program run.
-
If one does this, one finds the following pattern for the error in the pressure variable:
+
If one does this, one finds the following pattern for the error in the pressure variable:
Finite element order
@@ -1126,7 +1126,7 @@
The theoretically expected convergence orders are very nicely reflected by the experimentally observed ones indicated in the last row of the table.
-
One can make the same experiment with the error in the velocity variables:
+
One can make the same experiment with the error in the velocity variables:
Finite element order
/usr/share/doc/packages/dealii/doxygen/deal.II/step_21.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_21.html 2024-12-27 18:25:18.796942349 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_21.html 2024-12-27 18:25:18.800942377 +0000
@@ -168,7 +168,7 @@
The equations covered here are an extension of the material already covered in step-20. In particular, they fall into the class of vector-valued problems. A toplevel overview of this topic can be found in the Handling vector valued problems topic.
The two phase flow problem
Modeling of two phase flow in porous media is important for both environmental remediation and the management of petroleum and groundwater reservoirs. Practical situations involving two phase flow include the dispersal of a nonaqueous phase liquid in an aquifer, or the joint movement of a mixture of fluids such as oil and water in a reservoir. Simulation models, if they are to provide realistic predictions, must accurately account for these effects.
-
To derive the governing equations, consider two phase flow in a reservoir under the assumption that the movement of fluids is dominated by viscous effects; i.e. we neglect the effects of gravity, compressibility, and capillary pressure. Porosity will be considered to be constant. We will denote variables referring to either of the two phases using subscripts and , short for water and oil. The derivation of the equations holds for other pairs of fluids as well, however.
+
To derive the governing equations, consider two phase flow in a reservoir under the assumption that the movement of fluids is dominated by viscous effects; i.e. we neglect the effects of gravity, compressibility, and capillary pressure. Porosity will be considered to be constant. We will denote variables referring to either of the two phases using subscripts and , short for water and oil. The derivation of the equations holds for other pairs of fluids as well, however.
The velocity with which molecules of each of the two phases move is determined by Darcy's law that states that the velocity is proportional to the pressure gradient:
-
where is the velocity of phase , is the permeability tensor, is the relative permeability of phase , is the pressure and is the viscosity of phase . Finally, is the saturation (volume fraction), i.e. a function with values between 0 and 1 indicating the composition of the mixture of fluids. In general, the coefficients may be spatially dependent variables, and we will always treat them as non-constant functions in the following.
+
where is the velocity of phase , is the permeability tensor, is the relative permeability of phase , is the pressure and is the viscosity of phase . Finally, is the saturation (volume fraction), i.e. a function with values between 0 and 1 indicating the composition of the mixture of fluids. In general, the coefficients may be spatially dependent variables, and we will always treat them as non-constant functions in the following.
We combine Darcy's law with the statement of conservation of mass for each phase,
-
Here, is the sum source term, and
+
Here, is the sum source term, and
@@ -231,7 +231,7 @@
Note that the advection equation contains the term rather than to indicate that the saturation is not simply transported along; rather, since the two phases move with different velocities, the saturation can actually change even in the advected coordinate system. To see this, rewrite to observe that the actual velocity with which the phase with saturation is transported is whereas the other phase is transported at velocity . is consequently often referred to as the fractional flow.
+= \mathbf{u} F'(S) \cdot \nabla S$" src="form_3302.png"/> to observe that the actual velocity with which the phase with saturation is transported is whereas the other phase is transported at velocity . is consequently often referred to as the fractional flow.
In summary, what we get are the following two equations:
-
Here, are now time dependent functions: while at every time instant the flow field is in equilibrium with the pressure (i.e. we neglect dynamic accelerations), the saturation is transported along with the flow and therefore changes over time, in turn affected the flow field again through the dependence of the first equation on .
+
Here, are now time dependent functions: while at every time instant the flow field is in equilibrium with the pressure (i.e. we neglect dynamic accelerations), the saturation is transported along with the flow and therefore changes over time, in turn affected the flow field again through the dependence of the first equation on .
This set of equations has a peculiar character: one of the two equations has a time derivative, the other one doesn't. This corresponds to the character that the pressure and velocities are coupled through an instantaneous constraint, whereas the saturation evolves over finite time scales.
Such systems of equations are called Differential Algebraic Equations (DAEs), since one of the equations is a differential equation, the other is not (at least not with respect to the time variable) and is therefore an "algebraic" equation. (The notation comes from the field of ordinary differential equations, where everything that does not have derivatives with respect to the time variable is necessarily an algebraic equation.) This class of equations contains pretty well-known cases: for example, the time dependent Stokes and Navier-Stokes equations (where the algebraic constraint is that the divergence of the flow field, , must be zero) as well as the time dependent Maxwell equations (here, the algebraic constraint is that the divergence of the electric displacement field equals the charge density, and that the divergence of the magnetic flux density is zero: ); even the quasistatic model of step-18 falls into this category. We will see that the different character of the two equations will inform our discretization strategy for the two equations.
@@ -263,7 +263,7 @@
where is the length of a time step. Note how we solve the implicit pressure-velocity system that only depends on the previously computed saturation , and then do an explicit time step for that only depends on the previously known and the just computed . This way, we never have to iterate for the nonlinearities of the system as we would have if we used a fully implicit method. (In a more modern perspective, this should be seen as an "operator
splitting" method. step-58 has a long description of the idea behind this.)
-
We can then state the problem in weak form as follows, by multiplying each equation with test functions , , and and integrating terms by parts:
+
We can then state the problem in weak form as follows, by multiplying each equation with test functions , , and and integrating terms by parts:
-
Note that in the first term, we have to prescribe the pressure on the boundary as boundary values for our problem. denotes the unit outward normal vector to , as usual.
+
Note that in the first term, we have to prescribe the pressure on the boundary as boundary values for our problem. denotes the unit outward normal vector to , as usual.
For the saturation equation, we obtain after integrating by parts
DiscreteTime in order to keep track of the current value of time and time step in the code. This class encapsulates many complexities regarding adjusting time step size and stopping at a specified final time.
Space discretization
-
In each time step, we then apply the mixed finite method of step-20 to the velocity and pressure. To be well-posed, we choose Raviart-Thomas spaces for and discontinuous elements of class for . For the saturation, we will also choose spaces.
+
In each time step, we then apply the mixed finite method of step-20 to the velocity and pressure. To be well-posed, we choose Raviart-Thomas spaces for and discontinuous elements of class for . For the saturation, we will also choose spaces.
Since we have discontinuous spaces, we have to think about how to evaluate terms on the interfaces between cells, since discontinuous functions are not really defined there. In particular, we have to give a meaning to the last term on the left hand side of the saturation equation. To this end, let us define that we want to evaluate it in the following sense:
denotes the inflow boundary and is the outflow part of the boundary. The quantities then correspond to the values of these variables on the present cell, whereas (needed on the inflow part of the boundary of ) are quantities taken from the neighboring cell. Some more context on discontinuous element techniques and evaluation of fluxes can also be found in step-12.
Linear solvers
-
The linear solvers used in this program are a straightforward extension of the ones used in step-20 (but without LinearOperator). Essentially, we simply have to extend everything from two to three solution components. If we use the discrete spaces mentioned above and put shape functions into the bilinear forms, we arrive at the following linear system to be solved for time step :
+
The linear solvers used in this program are a straightforward extension of the ones used in step-20 (but without LinearOperator). Essentially, we simply have to extend everything from two to three solution components. If we use the discrete spaces mentioned above and put shape functions into the bilinear forms, we arrive at the following linear system to be solved for time step :
-
where the individual matrices and vectors are defined as follows using shape functions (of type Raviart Thomas ) for velocities and (of type ) for both pressures and saturations:
+
where the individual matrices and vectors are defined as follows using shape functions (of type Raviart Thomas ) for velocities and (of type ) for both pressures and saturations:
-
Note
Due to historical accidents, the role of matrices and has been reverted in this program compared to step-20. In other words, here refers to the divergence and to the gradient operators when it was the other way around in step-20.
+
Note
Due to historical accidents, the role of matrices and has been reverted in this program compared to step-20. In other words, here refers to the divergence and to the gradient operators when it was the other way around in step-20.
The system above presents a complication: Since the matrix depends on implicitly (the velocities are needed to determine which parts of the boundaries of cells are influx or outflux parts), we can only assemble this matrix after we have solved for the velocities.
The solution scheme then involves the following steps:
@@ -409,7 +409,7 @@
For simplicity, this program assumes that there is no source, , and that the heterogeneous porous medium is isotropic . The first one of these is a realistic assumption in oil reservoirs: apart from injection and production wells, there are usually no mechanisms for fluids to appear or disappear out of the blue. The second one is harder to justify: on a microscopic level, most rocks are isotropic, because they consist of a network of interconnected pores. However, this microscopic scale is out of the range of today's computer simulations, and we have to be content with simulating things on the scale of meters. On that scale, however, fluid transport typically happens through a network of cracks in the rock, rather than through pores. However, cracks often result from external stress fields in the rock layer (for example from tectonic faulting) and the cracks are therefore roughly aligned. This leads to a situation where the permeability is often orders of magnitude larger in the direction parallel to the cracks than perpendicular to the cracks. A problem typically faces in reservoir simulation, however, is that the modeler doesn't know the direction of cracks because oil reservoirs are not accessible to easy inspection. The only solution in that case is to assume an effective, isotropic permeability.
Whatever the matter, both of these restrictions, no sources and isotropy, would be easy to lift with a few lines of code in the program.
-
Next, for simplicity, our numerical simulation will be done on the unit cell for . Our initial conditions are ; in the oil reservoir picture, where would indicate the water saturation, this means that the reservoir contains pure oil at the beginning. Note that we do not need any initial conditions for pressure or velocity, since the equations do not contain time derivatives of these variables. Finally, we impose the following pressure boundary conditions:
+
Next, for simplicity, our numerical simulation will be done on the unit cell for . Our initial conditions are ; in the oil reservoir picture, where would indicate the water saturation, this means that the reservoir contains pure oil at the beginning. Note that we do not need any initial conditions for pressure or velocity, since the equations do not contain time derivatives of these variables. Finally, we impose the following pressure boundary conditions:
@@ -439,7 +439,7 @@
\]" src="form_3349.png"/>
Note
Coming back to this testcase in step-43 several years later revealed an oddity in the setup of this testcase. To this end, consider that we can rewrite the advection equation for the saturation as . Now, at the initial time, we have , and with the given choice of function , we happen to have . In other words, at , the equation reduces to for all , so the saturation is zero everywhere and it is going to stay zero everywhere! This is despite the fact that is not necessarily zero: the combined fluid is moving, but we've chosen our partial flux in such a way that infinitesimal amounts of wetting fluid also only move at infinitesimal speeds (i.e., they stick to the medium more than the non-wetting phase in which they are embedded). That said, how can we square this with the knowledge that wetting fluid is invading from the left, leading to the flow patterns seen in the results section? That's where we get into mathematics: Equations like the transport equation we are considering here have infinitely many solutions, but only one of them is physical: the one that results from the so-called viscosity limit, called the viscosity solution. The thing is that with discontinuous elements we arrive at this viscosity limit because using a numerical flux introduces a finite amount of artificial viscosity into the numerical scheme. On the other hand, in step-43, we use an artificial viscosity that is proportional to on every cell, which at the initial time is zero. Thus, the saturation there is zero and remains zero; the solution we then get is one solution of the advection equation, but the method does not converge to the viscosity solution without further changes. We will therefore use a different initial condition in that program.
+F'(S)) \cdot \nabla S = 0$" src="form_3350.png"/>. Now, at the initial time, we have , and with the given choice of function , we happen to have . In other words, at , the equation reduces to for all , so the saturation is zero everywhere and it is going to stay zero everywhere! This is despite the fact that is not necessarily zero: the combined fluid is moving, but we've chosen our partial flux in such a way that infinitesimal amounts of wetting fluid also only move at infinitesimal speeds (i.e., they stick to the medium more than the non-wetting phase in which they are embedded). That said, how can we square this with the knowledge that wetting fluid is invading from the left, leading to the flow patterns seen in the results section? That's where we get into mathematics: Equations like the transport equation we are considering here have infinitely many solutions, but only one of them is physical: the one that results from the so-called viscosity limit, called the viscosity solution. The thing is that with discontinuous elements we arrive at this viscosity limit because using a numerical flux introduces a finite amount of artificial viscosity into the numerical scheme. On the other hand, in step-43, we use an artificial viscosity that is proportional to on every cell, which at the initial time is zero. Thus, the saturation there is zero and remains zero; the solution we then get is one solution of the advection equation, but the method does not converge to the viscosity solution without further changes. We will therefore use a different initial condition in that program.
Finally, to come back to the description of the testcase, we will show results for computations with the two permeability functions introduced at the end of the results section of step-20:
A function that models a single, winding crack that snakes through the domain. In analogy to step-20, but taking care of the slightly different geometry we have here, we describe this by the following function:
- where the centers are randomly chosen locations inside the domain. This function models a domain in which there are centers of higher permeability (for example where rock has cracked) embedded in a matrix of more pristine, unperturbed background rock. Note that here we have cut off the permeability function both above and below to ensure a bounded condition number.
+ where the centers are randomly chosen locations inside the domain. This function models a domain in which there are centers of higher permeability (for example where rock has cracked) embedded in a matrix of more pristine, unperturbed background rock. Note that here we have cut off the permeability function both above and below to ensure a bounded condition number.
The commented program
This program is an adaptation of step-20 and includes some technique of DG methods from step-12. A good part of the program is therefore very similar to step-20 and we will not comment again on these parts. Only the new stuff will be discussed in more detail.
@@ -523,7 +523,7 @@
project_back_saturation resets all saturation degrees of freedom with values less than zero to zero, and all those with saturations greater than one to one.
-
The rest of the class should be pretty much obvious. The viscosity variable stores the viscosity that enters several of the formulas in the nonlinear equations. The variable time keeps track of the time information within the simulation.
+
The rest of the class should be pretty much obvious. The viscosity variable stores the viscosity that enters several of the formulas in the nonlinear equations. The variable time keeps track of the time information within the simulation.
 template <int dim>
 class TwoPhaseFlowProblem
 {
@@ -877,7 +877,7 @@
TwoPhaseFlowProblem class implementation
Here now the implementation of the main class. Much of it is actually copied from step-20, so we won't comment on it in much detail. You should try to get familiar with that program first, then most of what is happening here should be mostly clear.
TwoPhaseFlowProblem::TwoPhaseFlowProblem
-
First for the constructor. We use spaces. For initializing the DiscreteTime object, we don't set the time step size in the constructor because we don't have its value yet. The time step size is initially set to zero, but it will be computed before it is needed to increment time, as described in a subsection of the introduction. The time object internally prevents itself from being incremented when , forcing us to set a non-zero desired size for before advancing time.
+
First for the constructor. We use spaces. For initializing the DiscreteTime object, we don't set the time step size in the constructor because we don't have its value yet. The time step size is initially set to zero, but it will be computed before it is needed to increment time, as described in a subsection of the introduction. The time object internally prevents itself from being incremented when , forcing us to set a non-zero desired size for before advancing time.
 template <int dim>
 TwoPhaseFlowProblem<dim>::TwoPhaseFlowProblem(constunsignedint degree)
 : degree(degree)
@@ -1131,8 +1131,8 @@
 fe_values.get_function_values(old_solution, old_solution_values);
 fe_values.get_function_values(solution, present_solution_values);
Â
-
First for the cell terms. These are, following the formulas in the introduction, , where is the saturation component of the test function:
+
First for the cell terms. These are, following the formulas in the introduction, , where is the saturation component of the test function:
That's it. In the main function, we pass the degree of the finite element space to the constructor of the TwoPhaseFlowProblem object. Here, we use zero-th degree elements, i.e. . The rest is as in all the other programs.
+
That's it. In the main function, we pass the degree of the finite element space to the constructor of the TwoPhaseFlowProblem object. Here, we use zero-th degree elements, i.e. . The rest is as in all the other programs.
 int main()
 {
 try
@@ -1483,10 +1483,10 @@
...
As we can see, the time step is pretty much constant right from the start, which indicates that the velocities in the domain are not strongly dependent on changes in saturation, although they certainly are through the factor in the pressure equation.
Our second observation is that the number of CG iterations needed to solve the pressure Schur complement equation drops from 22 to 17 between the first and the second time step (in fact, it remains around 17 for the rest of the computations). The reason is actually simple: Before we solve for the pressure during a time step, we don't reset the solution variable to zero. The pressure (and the other variables) therefore have the previous time step's values at the time we get into the CG solver. Since the velocities and pressures don't change very much as computations progress, the previous time step's pressure is actually a good initial guess for this time step's pressure. Consequently, the number of iterations we need once we have computed the pressure once is significantly reduced.
-
The final observation concerns the number of iterations needed to solve for the saturation, i.e. one. This shouldn't surprise us too much: the matrix we have to solve with is the mass matrix. However, this is the mass matrix for the element of piecewise constants where no element couples with the degrees of freedom on neighboring cells. The matrix is therefore a diagonal one, and it is clear that we should be able to invert this matrix in a single CG iteration.
+
The final observation concerns the number of iterations needed to solve for the saturation, i.e. one. This shouldn't surprise us too much: the matrix we have to solve with is the mass matrix. However, this is the mass matrix for the element of piecewise constants where no element couples with the degrees of freedom on neighboring cells. The matrix is therefore a diagonal one, and it is clear that we should be able to invert this matrix in a single CG iteration.
With all this, here are a few movies that show how the saturation progresses over time. First, this is for the single crack model, as implemented in the SingleCurvingCrack::KInverse class:
-
As can be seen, the water rich fluid snakes its way mostly along the high-permeability zone in the middle of the domain, whereas the rest of the domain is mostly impermeable. This and the next movie are generated using n_refinement_steps=7, leading to a mesh with some 16,000 cells and about 66,000 unknowns in total.
+
As can be seen, the water rich fluid snakes its way mostly along the high-permeability zone in the middle of the domain, whereas the rest of the domain is mostly impermeable. This and the next movie are generated using n_refinement_steps=7, leading to a mesh with some 16,000 cells and about 66,000 unknowns in total.
The second movie shows the saturation for the random medium model of class RandomMedium::KInverse, where we have randomly distributed centers of high permeability and fluid hops from one of these zones to the next:
Finally, here is the same situation in three space dimensions, on a mesh with n_refinement_steps=5, which produces a mesh of some 32,000 cells and 167,000 degrees of freedom:
@@ -1494,24 +1494,24 @@
To repeat these computations, all you have to do is to change the line
TwoPhaseFlowProblem<2> two_phase_flow_problem(0);
in the main function to
TwoPhaseFlowProblem<3> two_phase_flow_problem(0);
The visualization uses a cloud technique, where the saturation is indicated by colored but transparent clouds for each cell. This way, one can also see somewhat what happens deep inside the domain. A different way of visualizing would have been to show isosurfaces of the saturation evolving over time. There are techniques to plot isosurfaces transparently, so that one can see several of them at the same time like the layers of an onion.
-
So why don't we show such isosurfaces? The problem lies in the way isosurfaces are computed: they require that the field to be visualized is continuous, so that the isosurfaces can be generated by following contours at least across a single cell. However, our saturation field is piecewise constant and discontinuous. If we wanted to plot an isosurface for a saturation , chances would be that there is no single point in the domain where that saturation is actually attained. If we had to define isosurfaces in that context at all, we would have to take the interfaces between cells, where one of the two adjacent cells has a saturation greater than and the other cell a saturation less than 0.5. However, it appears that most visualization programs are not equipped to do this kind of transformation.
+
So why don't we show such isosurfaces? The problem lies in the way isosurfaces are computed: they require that the field to be visualized is continuous, so that the isosurfaces can be generated by following contours at least across a single cell. However, our saturation field is piecewise constant and discontinuous. If we wanted to plot an isosurface for a saturation , chances would be that there is no single point in the domain where that saturation is actually attained. If we had to define isosurfaces in that context at all, we would have to take the interfaces between cells, where one of the two adjacent cells has a saturation greater than and the other cell a saturation less than 0.5. However, it appears that most visualization programs are not equipped to do this kind of transformation.
Possibilities for extensions
There are a number of areas where this program can be improved. Three of them are listed below. All of them are, in fact, addressed in a tutorial program that forms the continuation of the current one: step-43.
Solvers
-
At present, the program is not particularly fast: the 2d random medium computation took about a day for the 1,000 or so time steps. The corresponding 3d computation took almost two days for 800 time steps. The reason why it isn't faster than this is twofold. First, we rebuild the entire matrix in every time step, although some parts such as the , , and blocks never change.
-
Second, we could do a lot better with the solver and preconditioners. Presently, we solve the Schur complement with a CG method, using as a preconditioner. Applying this preconditioner is expensive, since it involves solving a linear system each time. This may have been appropriate for step-20, where we have to solve the entire problem only once. However, here we have to solve it hundreds of times, and in such cases it is worth considering a preconditioner that is more expensive to set up the first time, but cheaper to apply later on.
-
One possibility would be to realize that the matrix we use as preconditioner, is still sparse, and symmetric on top of that. If one looks at the flow field evolve over time, we also see that while changes significantly over time, the pressure hardly does and consequently . In other words, the matrix for the first time step should be a good preconditioner also for all later time steps. With a bit of back-and-forthing, it isn't hard to actually get a representation of it as a SparseMatrix object. We could then hand it off to the SparseMIC class to form a sparse incomplete Cholesky decomposition. To form this decomposition is expensive, but we have to do it only once in the first time step, and can then use it as a cheap preconditioner in the future. We could do better even by using the SparseDirectUMFPACK class that produces not only an incomplete, but a complete decomposition of the matrix, which should yield an even better preconditioner.
-
Finally, why use the approximation to precondition ? The latter matrix, after all, is the mixed form of the Laplace operator on the pressure space, for which we use linear elements. We could therefore build a separate matrix on the side that directly corresponds to the non-mixed formulation of the Laplacian, for example using the bilinear form . We could then form an incomplete or complete decomposition of this non-mixed matrix and use it as a preconditioner of the mixed form.
+
At present, the program is not particularly fast: the 2d random medium computation took about a day for the 1,000 or so time steps. The corresponding 3d computation took almost two days for 800 time steps. The reason why it isn't faster than this is twofold. First, we rebuild the entire matrix in every time step, although some parts such as the , , and blocks never change.
+
Second, we could do a lot better with the solver and preconditioners. Presently, we solve the Schur complement with a CG method, using as a preconditioner. Applying this preconditioner is expensive, since it involves solving a linear system each time. This may have been appropriate for step-20, where we have to solve the entire problem only once. However, here we have to solve it hundreds of times, and in such cases it is worth considering a preconditioner that is more expensive to set up the first time, but cheaper to apply later on.
+
One possibility would be to realize that the matrix we use as preconditioner, is still sparse, and symmetric on top of that. If one looks at the flow field evolve over time, we also see that while changes significantly over time, the pressure hardly does and consequently . In other words, the matrix for the first time step should be a good preconditioner also for all later time steps. With a bit of back-and-forthing, it isn't hard to actually get a representation of it as a SparseMatrix object. We could then hand it off to the SparseMIC class to form a sparse incomplete Cholesky decomposition. To form this decomposition is expensive, but we have to do it only once in the first time step, and can then use it as a cheap preconditioner in the future. We could do better even by using the SparseDirectUMFPACK class that produces not only an incomplete, but a complete decomposition of the matrix, which should yield an even better preconditioner.
+
Finally, why use the approximation to precondition ? The latter matrix, after all, is the mixed form of the Laplace operator on the pressure space, for which we use linear elements. We could therefore build a separate matrix on the side that directly corresponds to the non-mixed formulation of the Laplacian, for example using the bilinear form . We could then form an incomplete or complete decomposition of this non-mixed matrix and use it as a preconditioner of the mixed form.
/usr/share/doc/packages/dealii/doxygen/deal.II/step_22.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_22.html 2024-12-27 18:25:18.892943008 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_22.html 2024-12-27 18:25:18.896943036 +0000
@@ -180,36 +180,36 @@
This material is based upon work partly supported by the National Science Foundation under Award No. EAR-0426271 and The California Institute of Technology. Any opinions, findings, and conclusions or recommendations expressed in this publication are those of the author and do not necessarily reflect the views of the National Science Foundation or of The California Institute of Technology.
Introduction
This program deals with the Stokes system of equations which reads as follows in non-dimensionalized form:
-
+\end{eqnarray*}" src="form_3374.png"/>
-
where denotes the velocity of a fluid, is its pressure, are external forces, and is the rank-2 tensor of symmetrized gradients; a component-wise definition of it is .
+
where denotes the velocity of a fluid, is its pressure, are external forces, and is the rank-2 tensor of symmetrized gradients; a component-wise definition of it is .
The Stokes equations describe the steady-state motion of a slow-moving, viscous fluid such as honey, rocks in the earth mantle, or other cases where inertia does not play a significant role. If a fluid is moving fast enough that inertia forces are significant compared to viscous friction, the Stokes equations are no longer valid; taking into account inertia effects then leads to the nonlinear Navier-Stokes equations. However, in this tutorial program, we will focus on the simpler Stokes system.
Note that when deriving the more general compressible Navier-Stokes equations, the diffusion is modeled as the divergence of the stress tensor
-
+\end{eqnarray*}" src="form_3378.png"/>
-
where is the viscosity of the fluid. With the assumption of (assume constant viscosity and non-dimensionalize the equation by dividing out ) and assuming incompressibility ( ), we arrive at the formulation from above:
- is the viscosity of the fluid. With the assumption of (assume constant viscosity and non-dimensionalize the equation by dividing out ) and assuming incompressibility ( ), we arrive at the formulation from above:
+
+\end{eqnarray*}" src="form_3381.png"/>
-
A different formulation uses the Laplace operator ( ) instead of the symmetrized gradient. A big difference here is that the different components of the velocity do not couple. If you assume additional regularity of the solution (second partial derivatives exist and are continuous), the formulations are equivalent:
-) instead of the symmetrized gradient. A big difference here is that the different components of the velocity do not couple. If you assume additional regularity of the solution (second partial derivatives exist and are continuous), the formulations are equivalent:
+
+\end{eqnarray*}" src="form_3384.png"/>
-
This is because the th entry of is given by:
-th entry of is given by:
+
+\end{eqnarray*}" src="form_3386.png"/>
If you can not assume the above mentioned regularity, or if your viscosity is not a constant, the equivalence no longer holds. Therefore, we decided to stick with the more physically accurate symmetric tensor formulation in this tutorial.
To be well-posed, we will have to add boundary conditions to the equations. What boundary conditions are readily possible here will become clear once we discuss the weak form of the equations.
The equations covered here fall into the class of vector-valued problems. A toplevel overview of this topic can be found in the Handling vector valued problems topic.
Weak form
The weak form of the equations is obtained by writing it in vector form as
-
+\end{eqnarray*}" src="form_3387.png"/>
-
forming the dot product from the left with a vector-valued test function and integrating over the domain , yielding the following set of equations:
- and integrating over the domain , yielding the following set of equations:
+
+\end{eqnarray*}" src="form_3389.png"/>
-
which has to hold for all test functions .
+
which has to hold for all test functions .
A generally good rule of thumb is that if one can reduce how many derivatives are taken on any variable in the formulation, then one should in fact do that using integration by parts. (This is motivated by the theory of partial differential equations, and in particular the difference between strong and weak solutions.) We have already done that for the Laplace equation, where we have integrated the second derivative by parts to obtain the weak formulation that has only one derivative on both test and trial function.
In the current context, we integrate by parts the second term:
-
+\end{eqnarray*}" src="form_3391.png"/>
Likewise, we integrate by parts the first term to obtain
-
+\end{eqnarray*}" src="form_3392.png"/>
where the scalar product between two tensor-valued quantities is here defined as
-
+\end{eqnarray*}" src="form_3393.png"/>
-
Using this, we have now reduced the requirements on our variables to first derivatives for and no derivatives at all for .
-
Because the scalar product between a general tensor like and a symmetric tensor like equals the scalar product between the symmetrized forms of the two, we can also write the bilinear form above as follows:
- and no derivatives at all for .
+
Because the scalar product between a general tensor like and a symmetric tensor like equals the scalar product between the symmetrized forms of the two, we can also write the bilinear form above as follows:
+
+\end{eqnarray*}" src="form_3397.png"/>
We will deal with the boundary terms in the next section, but it is already clear from the domain terms
-
+\end{eqnarray*}" src="form_3398.png"/>
of the bilinear form that the Stokes equations yield a symmetric bilinear form, and consequently a symmetric (if indefinite) system matrix.
The weak form just derived immediately presents us with different possibilities for imposing boundary conditions:
-
Dirichlet velocity boundary conditions: On a part we may impose Dirichlet conditions on the velocity :
+
Dirichlet velocity boundary conditions: On a part we may impose Dirichlet conditions on the velocity :
-
+ \end{eqnarray*}" src="form_3400.png"/>
-
Because test functions come from the tangent space of the solution variable, we have that on and consequently that
- come from the tangent space of the solution variable, we have that on and consequently that
+
+ \end{eqnarray*}" src="form_3404.png"/>
In other words, as usual, strongly imposed boundary values do not appear in the weak form.
It is noteworthy that if we impose Dirichlet boundary values on the entire boundary, then the pressure is only determined up to a constant. An algorithmic realization of that would use similar tools as have been seen in step-11.
-
Neumann-type or natural boundary conditions: On the rest of the boundary , let us re-write the boundary terms as follows:
-Neumann-type or natural boundary conditions: On the rest of the boundary , let us re-write the boundary terms as follows:
+
Introduction
Note
The material presented here is also discussed in video lecture 28. (All video lectures are also available here.)
This is the first of a number of tutorial programs that will finally cover "real" time-dependent problems, not the slightly odd form of time dependence found in step-18 or the DAE model of step-21. In particular, this program introduces the wave equation in a bounded domain. Later, step-24 will consider an example of absorbing boundary conditions, and step-25 a kind of nonlinear wave equation producing solutions called solitons.
-
The wave equation in its prototypical form reads as follows: find that satisfies
- that satisfies
+
+\end{eqnarray*}" src="form_3483.png"/>
Note that since this is an equation with second-order time derivatives, we need to pose two initial conditions, one for the value and one for the time derivative of the solution.
-
Physically, the equation describes the motion of an elastic medium. In 2-d, one can think of how a membrane moves if subjected to a force. The Dirichlet boundary conditions above indicate that the membrane is clamped at the boundary at a height (this height might be moving as well — think of people holding a blanket and shaking it up and down). The first initial condition equals the initial deflection of the membrane, whereas the second one gives its velocity. For example, one could think of pushing the membrane down with a finger and then letting it go at (nonzero deflection but zero initial velocity), or hitting it with a hammer at (zero deflection but nonzero velocity). Both cases would induce motion in the membrane.
+
Physically, the equation describes the motion of an elastic medium. In 2-d, one can think of how a membrane moves if subjected to a force. The Dirichlet boundary conditions above indicate that the membrane is clamped at the boundary at a height (this height might be moving as well — think of people holding a blanket and shaking it up and down). The first initial condition equals the initial deflection of the membrane, whereas the second one gives its velocity. For example, one could think of pushing the membrane down with a finger and then letting it go at (nonzero deflection but zero initial velocity), or hitting it with a hammer at (zero deflection but nonzero velocity). Both cases would induce motion in the membrane.
Time discretization
Method of lines or Rothe's method?
There is a long-standing debate in the numerical analysis community over whether a discretization of time dependent equations should involve first discretizing the time variable leading to a stationary PDE at each time step that is then solved using standard finite element techniques (this is called the Rothe method), or whether one should first discretize the spatial variables, leading to a large system of ordinary differential equations that can then be handled by one of the usual ODE solvers (this is called the method of lines).
@@ -180,12 +180,12 @@
Rothe's method!
Given these considerations, here is how we will proceed: let us first define a simple time stepping method for this second order problem, and then in a second step do the spatial discretization, i.e. we will follow Rothe's approach.
For the first step, let us take a little detour first: in order to discretize a second time derivative, we can either discretize it directly, or we can introduce an additional variable and transform the system into a first order system. In many cases, this turns out to be equivalent, but dealing with first order systems is often simpler. To this end, let us introduce
-
+\]" src="form_3485.png"/>
and call this variable the velocity for obvious reasons. We can then reformulate the original wave equation as follows:
-
+\end{eqnarray*}" src="form_3486.png"/>
-
The advantage of this formulation is that it now only contains first time derivatives for both variables, for which it is simple to write down time stepping schemes. Note that we do not have boundary conditions for at first. However, we could enforce on the boundary. It turns out in numerical examples that this is actually necessary: without doing so the solution doesn't look particularly wrong, but the Crank-Nicolson scheme does not conserve energy if one doesn't enforce these boundary conditions.
-
With this formulation, let us introduce the following time discretization where a superscript indicates the number of a time step and is the length of the present time step:
- at first. However, we could enforce on the boundary. It turns out in numerical examples that this is actually necessary: without doing so the solution doesn't look particularly wrong, but the Crank-Nicolson scheme does not conserve energy if one doesn't enforce these boundary conditions.
+
With this formulation, let us introduce the following time discretization where a superscript indicates the number of a time step and is the length of the present time step:
+
+\end{eqnarray*}" src="form_3489.png"/>
-
Note how we introduced a parameter here. If we chose , for example, the first equation would reduce to , which is well-known as the forward or explicit Euler method. On the other hand, if we set , then we would get , which corresponds to the backward or implicit Euler method. Both these methods are first order accurate methods. They are simple to implement, but they are not really very accurate.
-
The third case would be to choose . The first of the equations above would then read . This method is known as the Crank-Nicolson method and has the advantage that it is second order accurate. In addition, it has the nice property that it preserves the energy in the solution (physically, the energy is the sum of the kinetic energy of the particles in the membrane plus the potential energy present due to the fact that it is locally stretched; this quantity is a conserved one in the continuous equation, but most time stepping schemes do not conserve it after time discretization). Since also appears in the equation for , the Crank-Nicolson scheme is also implicit.
+
Note how we introduced a parameter here. If we chose , for example, the first equation would reduce to , which is well-known as the forward or explicit Euler method. On the other hand, if we set , then we would get , which corresponds to the backward or implicit Euler method. Both these methods are first order accurate methods. They are simple to implement, but they are not really very accurate.
+
The third case would be to choose . The first of the equations above would then read . This method is known as the Crank-Nicolson method and has the advantage that it is second order accurate. In addition, it has the nice property that it preserves the energy in the solution (physically, the energy is the sum of the kinetic energy of the particles in the membrane plus the potential energy present due to the fact that it is locally stretched; this quantity is a conserved one in the continuous equation, but most time stepping schemes do not conserve it after time discretization). Since also appears in the equation for , the Crank-Nicolson scheme is also implicit.
In the program, we will leave as a parameter, so that it will be easy to play with it. The results section will show some numerical evidence comparing the different schemes.
-
The equations above (called the semidiscretized equations because we have only discretized the time, but not space), can be simplified a bit by eliminating from the first equation and rearranging terms. We then get
- from the first equation and rearranging terms. We then get
+
+\end{eqnarray*}" src="form_3497.png"/>
-
In this form, we see that if we are given the solution of the previous timestep, that we can then solve for the variables separately, i.e. one at a time. This is convenient. In addition, we recognize that the operator in the first equation is positive definite, and the second equation looks particularly simple.
+
In this form, we see that if we are given the solution of the previous timestep, that we can then solve for the variables separately, i.e. one at a time. This is convenient. In addition, we recognize that the operator in the first equation is positive definite, and the second equation looks particularly simple.
Space discretization
-
We have now derived equations that relate the approximate (semi-discrete) solution and its time derivative at time with the solutions of the previous time step at . The next step is to also discretize the spatial variable using the usual finite element methodology. To this end, we multiply each equation with a test function, integrate over the entire domain, and integrate by parts where necessary. This leads to
- and its time derivative at time with the solutions of the previous time step at . The next step is to also discretize the spatial variable using the usual finite element methodology. To this end, we multiply each equation with a test function, integrate over the entire domain, and integrate by parts where necessary. This leads to
+
+\end{eqnarray*}" src="form_3503.png"/>
-
It is then customary to approximate , where are the shape functions used for the discretization of the -th time step and are the unknown nodal values of the solution. Similarly, . Finally, we have the solutions of the previous time step, and . Note that since the solution of the previous time step has already been computed by the time we get to time step , are known. Furthermore, note that the solutions of the previous step may have been computed on a different mesh, so we have to use shape functions .
+
It is then customary to approximate , where are the shape functions used for the discretization of the -th time step and are the unknown nodal values of the solution. Similarly, . Finally, we have the solutions of the previous time step, and . Note that since the solution of the previous time step has already been computed by the time we get to time step , are known. Furthermore, note that the solutions of the previous step may have been computed on a different mesh, so we have to use shape functions .
If we plug these expansions into above equations and test with the test functions from the present mesh, we get the following linear system:
-
+\end{eqnarray*}" src="form_3512.png"/>
where
-
+\end{eqnarray*}" src="form_3513.png"/>
If we solve these two equations, we can move the solution one step forward and go on to the next time step.
-
It is worth noting that if we choose the same mesh on each time step (as we will in fact do in the program below), then we have the same shape functions on time step and , i.e. . Consequently, we get and . On the other hand, if we had used different shape functions, then we would have to compute integrals that contain shape functions defined on two meshes. This is a somewhat messy process that we omit here, but that is treated in some detail in step-28.
+
It is worth noting that if we choose the same mesh on each time step (as we will in fact do in the program below), then we have the same shape functions on time step and , i.e. . Consequently, we get and . On the other hand, if we had used different shape functions, then we would have to compute integrals that contain shape functions defined on two meshes. This is a somewhat messy process that we omit here, but that is treated in some detail in step-28.
Under these conditions (i.e. a mesh that doesn't change), one can optimize the solution procedure a bit by basically eliminating the solution of the second linear system. We will discuss this in the introduction of the step-25 program.
Energy conservation
-
One way to compare the quality of a time stepping scheme is to see whether the numerical approximation preserves conservation properties of the continuous equation. For the wave equation, the natural quantity to look at is the energy. By multiplying the wave equation by , integrating over , and integrating by parts where necessary, we find that
-, integrating over , and integrating by parts where necessary, we find that
+
+\]" src="form_3518.png"/>
By consequence, in absence of body forces and constant boundary values, we get that
-
+\]" src="form_3519.png"/>
-
is a conserved quantity, i.e. one that doesn't change with time. We will compute this quantity after each time step. It is straightforward to see that if we replace by its finite element approximation, and by the finite element approximation of the velocity , then
- by its finite element approximation, and by the finite element approximation of the velocity , then
+
+\]" src="form_3521.png"/>
As we will see in the results section, the Crank-Nicolson scheme does indeed conserve the energy, whereas neither the forward nor the backward Euler scheme do.
Who are Courant, Friedrichs, and Lewy?
One of the reasons why the wave equation is not easy to solve numerically is that explicit time discretizations are only stable if the time step is small enough. In particular, it is coupled to the spatial mesh width . For the lowest order discretization we use here, the relationship reads
-
+\]" src="form_3522.png"/>
-
where is the wave speed, which in our formulation of the wave equation has been normalized to one. Consequently, unless we use the implicit schemes with , our solutions will not be numerically stable if we violate this restriction. Implicit schemes do not have this restriction for stability, but they become inaccurate if the time step is too large.
+
where is the wave speed, which in our formulation of the wave equation has been normalized to one. Consequently, unless we use the implicit schemes with , our solutions will not be numerically stable if we violate this restriction. Implicit schemes do not have this restriction for stability, but they become inaccurate if the time step is too large.
This condition was first recognized by Courant, Friedrichs, and Lewy — in 1928, long before computers became available for numerical computations! (This result appeared in the German language article R. Courant, K. Friedrichs and H. Lewy: Über die partiellen Differenzengleichungen der mathematischen Physik, Mathematische Annalen, vol. 100, no. 1, pages 32-74, 1928.) This condition on the time step is most frequently just referred to as the CFL condition. Intuitively, the CFL condition says that the time step must not be larger than the time it takes a wave to cross a single cell.
-
In the program, we will refine the square seven times uniformly, giving a mesh size of , which is what we set the time step to. The fact that we set the time step and mesh size individually in two different places is error prone: it is too easy to refine the mesh once more but forget to also adjust the time step. step-24 shows a better way how to keep these things in sync.
+
In the program, we will refine the square seven times uniformly, giving a mesh size of , which is what we set the time step to. The fact that we set the time step and mesh size individually in two different places is error prone: it is too easy to refine the mesh once more but forget to also adjust the time step. step-24 shows a better way how to keep these things in sync.
The test case
-
Although the program has all the hooks to deal with nonzero initial and boundary conditions and body forces, we take a simple case where the domain is a square and
- and
+
The problem
The temperature at a given location, neglecting thermal diffusion, can be stated as
-
+\]" src="form_3553.png"/>
-
Here is the density; is the specific heat; is the temperature rise due to the delivered microwave energy; and is the heating function defined as the thermal energy per time and volume transformed from deposited microwave energy.
-
Let us assume that tissues have heterogeneous dielectric properties but homogeneous acoustic properties. The basic acoustic generation equation in an acoustically homogeneous medium can be described as follows: if is the vector-valued displacement, then tissue certainly reacts to changes in pressure by acceleration:
- is the density; is the specific heat; is the temperature rise due to the delivered microwave energy; and is the heating function defined as the thermal energy per time and volume transformed from deposited microwave energy.
+
Let us assume that tissues have heterogeneous dielectric properties but homogeneous acoustic properties. The basic acoustic generation equation in an acoustically homogeneous medium can be described as follows: if is the vector-valued displacement, then tissue certainly reacts to changes in pressure by acceleration:
+
+\]" src="form_3558.png"/>
Furthermore, it contracts due to excess pressure and expands based on changes in temperature:
-
+\]" src="form_3559.png"/>
Here, is a thermoexpansion coefficient.
-
Let us now make the assumption that heating only happens on a time scale much shorter than wave propagation through tissue (i.e. the temporal length of the microwave pulse that heats the tissue is much shorter than the time it takes a wave to cross the domain). In that case, the heating rate can be written as (where is a map of absorption strengths for microwave energy and is the Dirac delta function), which together with the first equation above will yield an instantaneous jump in the temperature at time . Using this assumption, and taking all equations together, we can rewrite and combine the above as follows:
- can be written as (where is a map of absorption strengths for microwave energy and is the Dirac delta function), which together with the first equation above will yield an instantaneous jump in the temperature at time . Using this assumption, and taking all equations together, we can rewrite and combine the above as follows:
+
+\]" src="form_3564.png"/>
-
where .
+
where .
This somewhat strange equation with the derivative of a Dirac delta function on the right hand side can be rewritten as an initial value problem as follows:
-
+\end{eqnarray*}" src="form_3566.png"/>
(A derivation of this transformation into an initial value problem is given at the end of this introduction as an appendix.)
-
In the inverse problem, it is the initial condition that one would like to recover, since it is a map of absorption strengths for microwave energy, and therefore presumably an indicator to discern healthy from diseased tissue.
+
In the inverse problem, it is the initial condition that one would like to recover, since it is a map of absorption strengths for microwave energy, and therefore presumably an indicator to discern healthy from diseased tissue.
In real application, the thermoacoustic source is very small as compared to the medium. The propagation path of the thermoacoustic waves can then be approximated as from the source to the infinity. Furthermore, detectors are only a limited distance from the source. One only needs to evaluate the values when the thermoacoustic waves pass through the detectors, although they do continue beyond. This is therefore a problem where we are only interested in a small part of an infinite medium, and we do not want waves generated somewhere to be reflected at the boundary of the domain which we consider interesting. Rather, we would like to simulate only that part of the wave field that is contained inside the domain of interest, and waves that hit the boundary of that domain to simply pass undisturbed through the boundary. In other words, we would like the boundary to absorb any waves that hit it.
In general, this is a hard problem: Good absorbing boundary conditions are nonlinear and/or numerically very expensive. We therefore opt for a simple first order approximation to absorbing boundary conditions that reads
-
+\]" src="form_3568.png"/>
-
Here, is the normal derivative at the boundary. It should be noted that this is not a particularly good boundary condition, but it is one of the very few that are reasonably simple to implement.
+
Here, is the normal derivative at the boundary. It should be noted that this is not a particularly good boundary condition, but it is one of the very few that are reasonably simple to implement.
Weak form and discretization
As in step-23, one first introduces a second variable, which is defined as the derivative of the pressure potential:
-
+\]" src="form_3570.png"/>
With the second variable, one then transforms the forward problem into two separate equations:
-
+\end{eqnarray*}" src="form_3571.png"/>
with initial conditions:
-
+\end{eqnarray*}" src="form_3572.png"/>
-
Note that we have introduced a right hand side here to show how to derive these formulas in the general case, although in the application to the thermoacoustic problem .
+
Note that we have introduced a right hand side here to show how to derive these formulas in the general case, although in the application to the thermoacoustic problem .
The semi-discretized, weak version of this model, using the general scheme introduced in step-23 is then:
-
+\end{eqnarray*}" src="form_3574.png"/>
where is an arbitrary test function, and where we have used the absorbing boundary condition to integrate by parts: absorbing boundary conditions are incorporated into the weak form by using
-
+\]" src="form_3575.png"/>
From this we obtain the discrete model by introducing a finite number of shape functions, and get
-
+\end{eqnarray*}" src="form_3576.png"/>
-
The matrices and are here as in step-23, and the boundary mass matrix
- and are here as in step-23, and the boundary mass matrix
+
+\]" src="form_3577.png"/>
results from the use of absorbing boundary conditions.
Above two equations can be rewritten in a matrix form with the pressure and its derivative as an unknown vector:
-
+\]" src="form_3578.png"/>
where
-
+\]" src="form_3579.png"/>
By simple transformations, one then obtains two equations for the pressure potential and its derivative, just as in the previous tutorial program:
-
+\end{eqnarray*}" src="form_3580.png"/>
What the program does
Compared to step-23, this programs adds the treatment of a simple absorbing boundary conditions. In addition, it deals with data obtained from actual experimental measurements. To this end, we need to evaluate the solution at points at which the experiment also evaluates a real pressure field. We will see how to do that using the VectorTools::point_value function further down below.
Appendix: PDEs with Dirac delta functions as right hand side and their transformation to an initial value problem
In the derivation of the initial value problem for the wave equation, we initially found that the equation had the derivative of a Dirac delta function as a right hand side:
-
+\]" src="form_3581.png"/>
-
In order to see how to transform this single equation into the usual statement of a PDE with initial conditions, let us make the assumption that the physically quite reasonable medium is at rest initially, i.e. for . Next, let us form the indefinite integral with respect to time of both sides:
- for . Next, let us form the indefinite integral with respect to time of both sides:
+
+\]" src="form_3584.png"/>
This immediately leads to the statement
-
/usr/share/doc/packages/dealii/doxygen/deal.II/step_25.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_25.html 2024-12-27 18:25:19.072944244 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_25.html 2024-12-27 18:25:19.076944272 +0000
@@ -166,14 +166,14 @@
\end{eqnarray*}" src="form_3621.png"/>
Discretization of the equations in time
-
Now, we can discretize the split formulation in time using the -method, which has a stencil of only two time steps. By choosing a , the latter discretization allows us to choose from a continuum of schemes. In particular, if we pick or , we obtain the first-order accurate explicit or implicit Euler method, respectively. Another important choice is , which gives the second-order accurate Crank-Nicolson scheme. Henceforth, a superscript
@@ -384,19 +384,19 @@
![$\Psi_i[\cdot]$](form_117_dark.png)
![$\Psi_i[\varphi]=\varphi(\hat{\mathbf{x}}_i)$](form_118_dark.png)
![$\Psi_i[\varphi_j]=\delta_{ij}$](form_119_dark.png)
![$\Psi_i[\varphi]=\varphi(\hat{\mathbf{x}}_i)_{c(i)}$](form_122_dark.png)
![$\Psi_i[\varphi]
+<dd><p class=](form_123_dark.png)
"Generalized support points" are, as the name suggests, a generalization of 
![$\Psi_i[\varphi]
+ $](form_126_dark.png)
![\[ m = I - \Delta t M. \]](form_361_dark.png)
![\[ m = I - \Delta t M. \]](form_353_dark.png)
![$[-1,1]$](form_594_dark.png)
![$[0,1]$](form_593_dark.png)
![$[-1,1]^d$](form_464_dark.png)
![$[0,1]^d$](form_905_dark.png)
![\[
(6) \quad Sa = (D - C \: A^{-1} \: B)a
-\]](form_1956_dark.png)
![\[
y = S^{-1} g'
- \]](form_1960_dark.png)
![$\in [0, 2^{\text{dim}} - 1]$](form_362_dark.png)
![\[ F: \mathcal{B} \subset
-R^{\text{chartdim}} \mapsto \mathcal{M} \subset R^{\text{spacedim}} \]](form_1508_dark.png)
![\[ F: \mathcal{B} \subset
+R^{\text{chartdim}} \mapsto \mathcal{M} \subset R^{\text{spacedim}} \]](form_1495_dark.png)
![\[ F^{-1}: \mathcal{M} \subset R^{\text{spacedim}} \mapsto \mathcal{B}
-\subset R^{\text{chartdim}} \]](form_1509_dark.png)
![\[ F^{-1}: \mathcal{M} \subset R^{\text{spacedim}} \mapsto \mathcal{B}
+\subset R^{\text{chartdim}} \]](form_1496_dark.png)
![\[
-\mathbf x^{\text{new}} = F(\sum_i w_i F^{-1}(\mathbf x_i)). \]](form_1510_dark.png)
![\[
+\mathbf x^{\text{new}} = F(\sum_i w_i F^{-1}(\mathbf x_i)). \]](form_1497_dark.png)
![$[0,1]\times \{0\}\times \{0\}$](form_1517_dark.png)
![$[0,1]\times \{0\}\times \{0\}$](form_1504_dark.png)
-
-
-
![$e\in\left]0,1\right[$](form_1481_dark.png)
![$e\in\left]0,1\right[$](form_1534_dark.png)
@@ -352,7 +352,7 @@
![$[\mathbf{u}]=\mathbf{u_1} - \mathbf{u_2}$](form_1215_dark.png)
![$[\mathbf{u}]=\mathbf{u_1} - \mathbf{u_2}$](form_1171_dark.png)
Fourier series on a reference element. The exponential form of the 
![\[
\int_0^1 \phi_k(x) \phi_l^\ast(x) dx=\delta_{kl}.
-\]](form_1252_dark.png)
![$ [-1;1] $](form_1266_dark.png)
![$ [0;1] $](form_1268_dark.png)
![$\frac 12 [(\nabla \phi_i(x_q)) +
-(\nabla \phi_i(x_q))^T]$](form_1335_dark.png)
![$\Psi_i[f]$](form_1070_dark.png)
![$ f_h(\mathbf x) = \sum_i \Psi_i[f] \varphi_i(\mathbf x)
-$](form_1072_dark.png)
![$\Psi_i[\varphi] = f_i(\varphi(\hat{\mathbf x}_i))$](form_1074_dark.png)
![$\Psi_i[\varphi] = \varphi(\hat{\mathbf x}_i)$](form_1076_dark.png)
![$\Psi_i[\varphi] = \varphi(\hat{\mathbf x}_i)_{c(i)}$](form_1077_dark.png)
![$\{\Psi[\varphi]\}_{i=0}^{N-1}$](form_1081_dark.png)
@@ -526,7 +526,7 @@
![$\varphi_j(\mathbf x)
= 2^{p-1}\left(x_j-\frac 12\right)^{p-1}
-\left[\prod_{i=0}^{dim-1}(x_i(1-x_i))\right]$](form_1233_dark.png)
![$[x_0,x_1]$](form_494_dark.png)
![$[x_0,x_{K-1}]$](form_495_dark.png)
![\[
-\Delta u = 0
\]](form_468_dark.png)
![$(-1,1)^2 \backslash [0,1]^2$](form_469_dark.png)
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html 2024-12-27 18:25:05.032847837 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1SignedDistance_1_1Sphere.html 2024-12-27 18:25:05.036847865 +0000
@@ -226,9 +226,9 @@
/usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html differs (HTML document, ASCII text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html 2024-12-27 18:25:05.144848606 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/classFunctions_1_1StokesLSingularity.html 2024-12-27 18:25:05.148848634 +0000
@@ -275,7 +275,7 @@
![$[0,1]^\text{dim}$](form_82_dark.png)
![$\mathbf\in [0,1]^d$](form_1358_dark.png)
![\[
\mathbf T(\mathbf x) =
J(\hat{\mathbf x})^{-T} \hat{\mathbf T}(\hat{\mathbf x})
J(\hat{\mathbf x})^{-1}.
-\]](form_1372_dark.png)
![\[J^{\dagger} = J^{-1}\]](form_1382_dark.png)
NonMatching::FEValues. The domain is assumed to be described by a level set function, 
![\[
N = \{x \in F : \psi(x) < 0 \}, \\
P = \{x \in F : \psi(x) > 0 \},
-\]](form_2117_dark.png)
![$[0, 1]^{dim-1}$](form_2173_dark.png)
![$[0, 1]^{dim-1}$](form_2118_dark.png)
![\[
N = \{x \in K : \psi(x) < 0 \}, \\
P = \{x \in K : \psi(x) > 0 \}, \\
S = \{x \in K : \psi(x) = 0 \}.
-\]](form_2114_dark.png)
![$[0, 1]^{dim}$](form_2171_dark.png)
![$[0, 1]^{dim}$](form_2116_dark.png)
![\[
N = \{x \in F : \psi(x) < 0 \}, \\
P = \{x \in F : \psi(x) > 0 \}, \\
S = \{x \in F : \psi(x) = 0 \},
-\]](form_2157_dark.png)
![\[
\int_{S\cap K} f dS =
\int_{S\cap K} f |d\bar{S}| =
\int_{\hat{S}\cap\hat{K}} f \circ F_{K} \det(J) |\left( J^{-1} \right
)^T d\hat{S}|,
-\]](form_2131_dark.png)
![\[
\Delta \hat{S}_q \dealcoloneq w_q \hat{n}_q \approx d\hat{S}(\hat{x}_q),
-\]](form_2134_dark.png)
![$t \in [0,T]$](form_2137_dark.png)
![\[
\int_{S\cap F} f dr
= \int_{0}^T f(\bar{r}(t)) \left \|\frac{d\bar{r}}{dt} \right \| dt
= \int_{0}^T f(F_K(\hat{r}(t))) \left \| J \frac{d\hat{r}}{dt} \right \| dt
\approx \sum_{q} f \left(F_{K}(\hat{x}_{q}) \right) \|J(\hat{x}_q)
\hat{t}_q \| w_q,
-\]](form_2141_dark.png)
![$[x_0, x_1, ..., x_n]$](form_2217_dark.png)
![$[L, R]$](form_2189_dark.png)
![$[x_i, x_{i+1}]$](form_2220_dark.png)
![$[x_1, x_{n-1}]$](form_2221_dark.png)
![$[x_0, x_1, ..., x_n]$](form_2208_dark.png)
![$[L, R]$](form_2180_dark.png)
![$I \times [L, R] \subset \mathbb{R}^{dim}$](form_2191_dark.png)
![$[y_0, y_1, ..., y_n]$](form_2196_dark.png)
![$[y_i, y_{i+1}]$](form_2200_dark.png)
![$[A-\sigma B]^{-1}$](form_1804_dark.png)
![$[0,\text{dim}^{\text{rank}}-1]$](form_900_dark.png)
![$[0,\text{dim}^{\text{rank}}-1]$](form_897_dark.png)
![$[0, \text{dim}^{\text{rank}}-1]$](form_901_dark.png)
![\[
0 < \alpha < \frac{2}{\lambda_{\max}(P^{-1}A)}.
\]](form_1831_dark.png)
![$B_{ij} = v[j][i]-v[0][i]$](form_784_dark.png)
![$[0,x_0]$](form_749_dark.png)
![$[x_0,1]$](form_750_dark.png)
![\[ \int_0^1 g(x) dx = \int_0^1 f(x)
\ln\left(\frac{|x-x_0|}{\alpha}\right) dx = \sum_{i=0}^N w_i g(q_i) =
\sum_{i=0}^N \bar{w}_i f(q_i) \]](form_751_dark.png)
![$[0,1]^2$](form_756_dark.png)
![$QR= A = [a_1\,\dots a_n], \quad a_i \in {\mathbb R}^m$](form_1857_dark.png)
![$\tilde Q \tilde R= \tilde A = [a_2\,\dots a_n], \quad a_i \in {\mathbb
R}^m$](form_1858_dark.png)
-
![\[
a_i \dealcoloneq
M y_{n-1} + h_n \sum_{j=1}^{i-1} [ A^E_{i,j} f_E(t^E_{n,j}, z_j)
+ A^I_{i,j} f_I (t^I_{n,j}, z_j)]
- \]](form_2664_dark.png)
![\[
N(z_i^m) \delta^{m+1} = -G(z_i^m),
- \]](form_2671_dark.png)
ARKode may solve for each stage 
![\[
z_i^{m+1} = g(z_i^{m}), m=0,1,\ldots.
- \]](form_2674_dark.png)
![$y(t) = [u(t), v(t)]^T$](form_2762_dark.png)
![\[
u'(t) = au(t)
- \]](form_2730_dark.png)
step-47, the difficulty is the presence of the fourth derivatives. One way in which one can address this is by introducing an auxiliary variable 
![$v(t)=[e^{at}]^p$](form_2777_dark.png)
![$t\in[0,1]$](form_1476_dark.png)
-
![$I_2(\mathbf A) = II(\mathbf A) = \frac 12
\left[ (A_{11} + A_{22})^2 - (A_{11}^2+2 A_{12}^2+ A_{22}^2) \right]
- = A_{11} A_{22} - A_{12}^2$](form_830_dark.png)
![$\lambda_1, \lambda_2 = \frac{1}{2} \left[ \text{tr} \mathbf{T} \pm
\sqrt{(\text{tr} \mathbf{T})^2 - 4 \det \mathbf{T}} \right]$](form_833_dark.png)
![$[\nabla_u F(u)]^{-1}$](form_2810_dark.png)
![$[0, 1]^d$](form_1436_dark.png)
![$[0, 1]^d$](form_1394_dark.png)
Wikipedia article), let us think about the representation of the calculation of the function 
![$f(x,y) = [2x+1]^{y}$](form_22_dark.png)
![$\dfrac{d f(x,y)}{d x} = 2y[2x+1]^{y-1}$](form_25_dark.png)
![$\dfrac{d f(x,y)}{d y} = [2x+1]^{y} \ln(2x+1)$](form_26_dark.png)
![$\dfrac{d f(x, y)}{d x} \rightarrow \dfrac{\partial f(x, y(x))}{\partial x} = 2y(x) [2x+1]^{y(x)-1} = 4x[2x+1]^{2x-1}$](form_33_dark.png)
![\[
x \leftarrow C\,x+k.
\]](form_76_dark.png)
primitive element: an element that may be vector-valued but where each shape function has exactly one non-zero component. In other words: if the 
![$f = [3+a]_{a=1} = 4$](form_969_dark.png)
![$f\vert_{a=b+2, b} = [b+2+b]_{b=1} = 4$](form_979_dark.png)
![$\Psi_i[\varphi_j] = \delta_{ij}$](form_1289_dark.png)
![\begin{align*}
\Psi_i [\varphi_j] = \sum_{k=1}^N c_{jk} \Psi_i[\tilde\varphi_k],
\end{align*}](form_1291_dark.png)
![$X_{ik} = \Psi_i[\tilde\varphi_k]$](form_1294_dark.png)
![$\Psi_i[\tilde\varphi_j] = f_j(\tilde\varphi_j(\mathbf x_i))$](form_1299_dark.png)
![$f(x) \in [L, U]$](form_544_dark.png)
![$f(x) \in [f(x_c) - F, f(x_c) + F]$](form_545_dark.png)
![$\partial_i f \in [\partial_i f(x_c) - G_i, \partial_i f(x_c) + G_i]$](form_548_dark.png)
![$[left,right]^{\text{dim}}$](form_1395_dark.png)
@@ -725,7 +725,7 @@
@@ -1893,7 +1893,7 @@
![\[
N(m) = (N_0-m) + 2^d m = N_0 + (2^d-1)m
\]](form_1451_dark.png)
![\[
\eta^\text{exp}(m)
=
@@ -354,8 +354,8 @@
\sum_{K, K\; \text{will be refined}} 2^{-\text{order}}\eta_K
\]](form_1454_dark.png)
![\[
J(m) = N(m)^{\text{order}/d} \eta^\text{exp}(m)
\]](form_1457_dark.png)
![\[ \min\, \int \frac{1}{2}
c(\mathbf x)
\mathbf \nabla u_d(\mathbf x) \cdot
\mathbf \nabla u_d(\mathbf x)
\,\rm d x
-\]](form_1463_dark.png)
![$(0,max]$](form_2502_dark.png)
![\[ m_{ij} = \int_Z u_j\,(\mathbf w \cdot \nabla) v_i
-\, dx. \]](form_1600_dark.png)
![\[ m_{ij} = \int_Z u_j\,(\mathbf w \cdot \nabla) v_i
+\, dx. \]](form_1588_dark.png)
![\[ r_i = \int_Z (\mathbf w \cdot \nabla)u\, v_i \, dx. \]](form_1602_dark.png)
![\[ r_i = \int_Z (\mathbf w \cdot \nabla)u\, v_i \, dx. \]](form_1589_dark.png)
![\[ r_i = \int_Z \bigl((\mathbf w \cdot \nabla) \mathbf u\bigr)
-\cdot\mathbf v_i \, dx. \]](form_1605_dark.png)
![\[ r_i = \int_Z \bigl((\mathbf w \cdot \nabla) \mathbf u\bigr)
+\cdot\mathbf v_i \, dx. \]](form_1590_dark.png)
![\[ r_i = \int_Z (\mathbf w \cdot \nabla)v\, u_i \, dx. \]](form_1606_dark.png)
![\[ r_i = \int_Z (\mathbf w \cdot \nabla)v\, u_i \, dx. \]](form_1591_dark.png)
![\[ r_i = \int_Z \bigl((\mathbf w \cdot \nabla) \mathbf v\bigr)
-\cdot\mathbf u_i \, dx. \]](form_1608_dark.png)
![\[ r_i = \int_Z \bigl((\mathbf w \cdot \nabla) \mathbf v\bigr)
+\cdot\mathbf u_i \, dx. \]](form_1592_dark.png)
![\[ \int_Z v\nabla \cdot \mathbf u \,dx \]](form_1597_dark.png)
![\[ \int_Z
+v\nabla \cdot \mathbf u \,dx \]](form_1598_dark.png)
![\[ - \int_Z
+\nabla v \cdot \mathbf u \,dx \]](form_1599_dark.png)
![\[ \int_Z
+\mathbf v\cdot\nabla u \,dx \]](form_1601_dark.png)
![\[ -\int_Z
-\nabla\cdot \mathbf v u \,dx \]](form_1593_dark.png)
![\[ \int_F (\mathbf u\cdot \mathbf n) v \,ds \]](form_1594_dark.png)
![\[ \int_F (\mathbf u\cdot \mathbf n) v \,ds \]](form_1603_dark.png)
![\[ \int_Z \varepsilon(u): \varepsilon(v)\,dx \]](form_1613_dark.png)
![\[ - \int_Z \varepsilon(u): \varepsilon(v) \,dx \]](form_1614_dark.png)
![\[ \int_F [\gamma u][\gamma v]\,ds \quad \text{or}
\int_F [\gamma \mathbf u]\cdot [\gamma \mathbf v]\,ds \]](form_1628_dark.png)
![\[ \int_Z \nu \nabla u \cdot \nabla v \, dx. \]](form_1642_dark.png)
![\[ \int_Z \nu \nabla u : \nabla v \, dx. \]](form_1644_dark.png)
![\[ \int_Z \nu \nabla u : \nabla v \, dx. \]](form_1631_dark.png)
![\[
M_{ij} \dealcoloneq \int_{B} v_i(x) w_j(x) dx,
@@ -250,9 +250,9 @@
\]](form_2100_dark.png)
![$[L_j, U_j]$](form_2222_dark.png)
![$[L, U]$](form_2223_dark.png)
![$[\min(L, L_f), \max(U, U_f)]$](form_2814_dark.png)
![$[y_0, y_{n+1}]$](form_2830_dark.png)
const std::optional< 
![\[
M_{i,j} \dealcoloneq v_j(x_i) ,
-\]](form_2514_dark.png)
![$[0, \pi]$](form_2619_dark.png)
![$[-\pi, \pi]$](form_2623_dark.png)
Fourier series expansion 
![\[
|a_{\bf k}| = {\cal O}\left(\|{\bf k}\|_2^
{-\left(s + \frac d2 + \epsilon \right)} \right)
-\]](form_2325_dark.png)
![\[
\min_{\alpha,\sigma}
\frac 12 \sum_{{\bf k}, \|{\bf k}\|_2 \le p}
\left( |a_{\bf k}| - \alpha \|{\bf k}\|_2^{-\sigma}\right)^2
-\]](form_2327_dark.png)
![\[
\min_{\beta,\sigma}
Q(\beta,\sigma) =
\frac 12 \sum_{{\bf k}, \|{\bf k}\|_2 \le p}
\left( \ln |a_{\bf k}| - \beta + \sigma \ln \|{\bf k}\|_2
\right)^2,
-\]](form_2328_dark.png)
![\[
\left(\begin{array}{cc}
\sum_{{\bf k}, \|{\bf k}\|_2 \le p} 1 &
\sum_{{\bf k}, \|{\bf k}\|_2 \le p} \ln \|{\bf k}\|_2
@@ -193,10 +193,10 @@
\\
\sum_{{\bf k}, \|{\bf k}\|_2\le p} \ln |a_{{\bf k}}| \ln \|{\bf
k}\|_2 \end{array}\right)
-\]](form_2332_dark.png)
integrate_difference() function on each cell and 
![\[
\int_A f(x) dx \approx \sum_q f(x_q) \omega_q.
-\]](form_2398_dark.png)
![\[
E = \int_\Omega (\hat{f} - f)
= \int_\Omega e.
-\]](form_2403_dark.png)
![\[
E = \| e \|_{L^1}.
-\]](form_2408_dark.png)
![\[
E = \sqrt{ \int_\Omega e^2 }
= \| e \|_{L^2}
-\]](form_2411_dark.png)
![\[
E_K = \left( \int_K \sum_c |e_c|^p \, w_c \right)^{1/p}
-\]](form_2412_dark.png)
![\[
E = \| e \|_{L^p}.
-\]](form_2414_dark.png)
![\[
E = \sup_\Omega \|e\|_\infty = \| e \|_{L^\infty}.
-\]](form_2417_dark.png)
![\[
\Gamma_- \dealcoloneq \{{\bf x}\in\Gamma, {\mathbf \beta}({\bf x})\cdot{\bf n}({\bf x})<0\}
\]](form_2907_dark.png)
![\[
a(\varphi,z) = J(\varphi) \qquad \forall \varphi,
-\]](form_2946_dark.png)
![\[
J(e) = a(e,z)
-\]](form_2949_dark.png)
![\[
[\partial_n u_h] \dealcoloneq \partial_n u_h|_K + \partial_{n'} u_h|_{K'}
=
\partial_n u_h|_K - \partial_n u_h|_{K'},
-\]](form_2961_dark.png)
![\begin{eqnarray*}
J(e)
&=&
\sum_K (f+\Delta u_h, z-I_h z)_K
- \frac 12 ([\partial_n u_h],
z-I_h z)_{\partial K\backslash \partial\Omega}.
-\end{eqnarray*}](form_2963_dark.png)
![$[\partial_n u_h]$](form_3048_dark.png)
![$[\partial_n u_h]$](form_2966_dark.png)
![\[
-\Delta z = \delta(x-x_0),
-\]](form_2969_dark.png)
![$[\partial_n
-u]=0$](form_3057_dark.png)
![$[\partial_n
+u]=0$](form_2975_dark.png)
![\[
F'(u,\delta u)=\lim \limits_{\epsilon \rightarrow 0}{\frac{F(u+\epsilon \delta u)-
F(u)}{\epsilon}}.
-\]](form_2992_dark.png)
![\[
\left( \nabla \varphi , \frac{1}{\left(1+|\nabla u^{n}|^{2}\right)^{\frac{1}{2}}}\nabla
\delta u^{n} \right)-\left(\nabla \varphi ,\frac{\nabla u^{n} \cdot \nabla
\delta u^{n}}{\left(1+|\nabla u^{n}|^{2}\right)^{\frac{3}{2}}}\nabla u^{n} \right)
= -\left(\nabla \varphi , \frac{1}{\left(1+|\nabla u^{n}|^{2}\right)^{\frac{1}{2}}} \nabla u^{n}
\right).
- \]](form_3002_dark.png)
![\[
B
=
a_n \left\{
@@ -279,44 +279,44 @@
\frac{\nabla u_n}{\sqrt{1+|\nabla u^{n}|^{2}}} \otimes
\frac{\nabla u_n}{\sqrt{1+|\nabla u^{n}|^{2}}}
\right\}.
-\]](form_3016_dark.png)
![\[
\mathbf{u}(\cdot, 0) = \mathbf{u}_0(\cdot)
\qquad
\textrm{on}\ \Omega,
-\]](form_3068_dark.png)
![\[
\dot\sigma = C \varepsilon (\dot{\mathbf{u}}),
\qquad
\qquad
\textrm{[stress-strain]}
-\]](form_3080_dark.png)
![\[
-\textrm{div}\ \sigma^n = f^n,
-\]](form_3082_dark.png)
![\begin{align*}
(C \varepsilon(\Delta\mathbf{u}^n), \varepsilon(\varphi) )_{\Omega(t_{n-1})}
&=
(\mathbf{f}, \varphi)_{\Omega(t_{n-1})}
@@ -294,32 +294,32 @@
\qquad
\qquad
\textrm{[linear-system]}
-\end{align*}](form_3090_dark.png)
![\[
\sigma^n = \sigma^{n-1} + C \varepsilon (\Delta \mathbf{u}^n).
\qquad
\qquad
\textrm{[stress-update]}
-\]](form_3099_dark.png)
![\[
(\sigma^{n-1},\varepsilon(\varphi))_{\Omega(t_{n-1})}
=
\sum_{K\subset {T}}
@@ -328,12 +328,12 @@
\sum_{K\subset {T}}
\sum_q
w_q \ \sigma^{n-1}(\mathbf{x}_q) : \varepsilon(\varphi(\mathbf{x}_q),
-\]](form_3103_dark.png)
![\begin{eqnarray*}
\tilde S^{-1} = [B^T ({\textrm{diag}\ }M)^{-1}B]^{-1}
\end{eqnarray*}](form_3265_dark.png)
![\[
\lambda(S) = \frac{k_{rw}(S)}{\mu_{w}}+\frac{k_{ro}(S)}{\mu_{o}}
\]](form_3290_dark.png)
![\begin{eqnarray*}
- \nabla \cdot (\mathbf{K}\lambda(S) \nabla p) &=& q
@@ -241,7 +241,7 @@
\qquad \textrm{in}\ \Omega\times[0,T].
\end{eqnarray*}](form_3305_dark.png)
DiscreteTime in order to keep track of the current value of time and time step in the code. This class encapsulates many complexities regarding adjusting time step size and stopping at a specified final time.
![\[
\left(
\begin{array}{ccc}
@@ -342,7 +342,7 @@
\right)
\]](form_3329_dark.png)
![$\Omega = [0,1]\times [0,1]$](form_3341_dark.png)
![$t\in [0,T]$](form_3342_dark.png)
![\[
p(\mathbf{x},t)=1-x_1 \qquad \textrm{on}\ \partial\Omega.
\]](form_3344_dark.png)
![$[B^T (\textrm{diag}(M^u(S)))^{-1} B]^{-1}$](form_3421_dark.png)
![$[B^T (\textrm{diag}(M^u(S)))^{-1} B]^{-1}$](form_3367_dark.png)
![$\varepsilon(\textbf{u})= \nabla^s{\textbf{u}}= \frac 12 \left[
-(\nabla \textbf{u}) + (\nabla \textbf{u})^T\right]$](form_3511_dark.png)
![$\varepsilon(\textbf{u})= \nabla^s{\textbf{u}}= \frac 12 \left[
+(\nabla \textbf{u}) + (\nabla \textbf{u})^T\right]$](form_3376_dark.png)
![\begin{eqnarray*}
[\nabla \cdot (\nabla\textbf{u})^T]_i
= \sum_j \frac{\partial}{\partial x_j} [(\nabla\textbf{u})^T]_{i,j}
= \sum_j \frac{\partial}{\partial x_j} [(\nabla\textbf{u})]_{j,i}
@@ -218,14 +218,14 @@
= \frac{\partial}{\partial x_i}
\underbrace{\textrm{div}\; \textbf{u}}_{=0}
= 0.
-\end{eqnarray*}](form_3386_dark.png)
Neumann-type or natural boundary conditions: On the rest of the boundary ![\begin{eqnarray*}
-(\textbf{n} \otimes \mathrm
v, 2\; \varepsilon(\textbf{u}))_{\Gamma_N}
+
@@ -362,17 +362,17 @@
&=&
(\textbf{v},
\textbf{n}\cdot [p \textbf{I} - 2\; \varepsilon(\textbf{u})])_{\Gamma_N}.
/usr/share/doc/packages/dealii/doxygen/deal.II/step_23.html differs (HTML document, UTF-8 Unicode text, with very long lines)
--- old//usr/share/doc/packages/dealii/doxygen/deal.II/step_23.html 2024-12-27 18:25:18.956943448 +0000
+++ new//usr/share/doc/packages/dealii/doxygen/deal.II/step_23.html 2024-12-27 18:25:18.964943503 +0000
@@ -145,8 +145,8 @@
<a class=](form_3406_dark.png)
![\begin{eqnarray*}
\frac{u^n - u^{n-1}}{k}
- \left[\theta v^n + (1-\theta) v^{n-1}\right] &=& 0,
\\
\frac{v^n - v^{n-1}}{k}
- \Delta\left[\theta u^n + (1-\theta) u^{n-1}\right]
&=& \theta f^n + (1-\theta) f^{n-1}.
-\end{eqnarray*}](form_3489_dark.png)
![$\frac{u^n - u^{n-1}}{k}
+- \frac 12 \left[v^n + v^{n-1}\right] = 0$](form_3495_dark.png)
![\begin{eqnarray*}
\left[ 1-k^2\theta^2\Delta \right] u^n &=&
\left[ 1+k^2\theta(1-\theta)\Delta\right] u^{n-1} + k v^{n-1}
+ k^2\theta\left[\theta f^n + (1-\theta) f^{n-1}\right],\\
v^n &=& v^{n-1} + k\Delta\left[ \theta u^n + (1-\theta) u^{n-1}\right]
+ k\left[\theta f^n + (1-\theta) f^{n-1}\right].
-\end{eqnarray*}](form_3497_dark.png)
![\begin{eqnarray*}
(u^n,\varphi) + k^2\theta^2(\nabla u^n,\nabla \varphi) &=&
(u^{n-1},\varphi) - k^2\theta(1-\theta)(\nabla u^{n-1},\nabla \varphi)
+
@@ -260,15 +260,15 @@
\left[
\theta (f^n,\varphi) + (1-\theta) (f^{n-1},\varphi)
\right].
-\end{eqnarray*}](form_3503_dark.png)
![\[
\rho \frac{\partial^2}{\partial t^2}u(t,\mathbf r) =
-\nabla p(t,\mathbf r).
-\]](form_3558_dark.png)
![\[
\Delta p-\frac{1}{c_0^2} \frac{\partial^2 p}{\partial t^2} = \lambda
a(\mathbf r)\frac{d\delta(t)}{dt}
-\]](form_3564_dark.png)
![\[
B_{ij} = \left(\varphi_i,\varphi_j\right)_{\partial\Omega}
-\]](form_3577_dark.png)
![\[
\int^t \Delta p\; dt -\int^t \frac{1}{c_0^2} \frac{\partial^2 p}{\partial t^2}
\; dt
=
\int^t \lambda a(\mathbf r)\frac{d\delta(t)}{dt} \;dt.
-\]](form_3584_dark.png)
![$\theta\in [0,1]$](form_3622_dark.png)
