--- /srv/rebuilderd/tmp/rebuilderdDdQgXO/inputs/libdeal.ii-doc_9.7.1-1_all.deb
+++ /srv/rebuilderd/tmp/rebuilderdDdQgXO/out/libdeal.ii-doc_9.7.1-1_all.deb
├── file list
│ @@ -1,3 +1,3 @@
│ -rw-r--r-- 0 0 0 4 2025-11-26 10:29:04.000000 debian-binary
│ --rw-r--r-- 0 0 0 271552 2025-11-26 10:29:04.000000 control.tar.xz
│ --rw-r--r-- 0 0 0 287479328 2025-11-26 10:29:04.000000 data.tar.xz
│ +-rw-r--r-- 0 0 0 271500 2025-11-26 10:29:04.000000 control.tar.xz
│ +-rw-r--r-- 0 0 0 287479156 2025-11-26 10:29:04.000000 data.tar.xz
├── control.tar.xz
│ ├── control.tar
│ │ ├── ./control
│ │ │ @@ -1,13 +1,13 @@
│ │ │ Package: libdeal.ii-doc
│ │ │ Source: deal.ii
│ │ │ Version: 9.7.1-1
│ │ │ Architecture: all
│ │ │ Maintainer: Debian Science Maintainers The cell will be or was refined. The children of this cell will be or were coarsened into this cell. Invalid status. Will not occur for the user. Definition at line 30 of file cell_status.h. Constructor. The supplied IndexSet defines for which indices this object will store constraints. In a calculation with a DoFHandler object based on parallel::distributed::Triangulation or parallel::shared::Triangulation, one should use the set of locally relevant DoFs (see GlossLocallyRelevantDof). The given IndexSet allows the AffineConstraints container to save memory by just not caring about degrees of freedom that are not of importance to the current processor. In contrast, in parallel computations, if you do not provide such an index set (here, or using the reinit() function that takes such an argument), the current object will allocate memory proportional to the total number of degrees of freedom (accumulated over all processes), which is clearly wasteful and not efficient – and should be considered a bug. Definition at line 2343 of file affine_constraints.h. clear() the AffineConstraints object and supply an IndexSet that describes for which degrees of freedom this object can store constraints. See the discussion in the documentation of the constructor of this class that takes a single index set as argument. This function copies the content of If, for example, the filter represents the range This function provides an easy way to create a AffineConstraints for certain vector components in a vector-valued problem from a full AffineConstraints, i.e. extracting a diagonal subblock from a larger AffineConstraints. The block is specified by the IndexSet argument. This is the base class for block versions of the sparsity pattern and dynamic sparsity pattern classes. It has not much functionality, but only administrates an array of sparsity pattern objects and delegates work to them. It has mostly the same interface as has the SparsityPattern, and DynamicSparsityPattern, and simply transforms calls to its member functions to calls to the respective member functions of the member sparsity patterns. The largest difference between the SparsityPattern and DynamicSparsityPattern classes and this class is that mostly, the matrices have different properties and you will want to work on the blocks making up the matrix rather than the whole matrix. You can access the different blocks using the Attention: this object is not automatically notified if the size of one of its subobjects' size is changed. After you initialize the sizes of the subobjects, you will therefore have to call the You will in general not want to use this class, but one of the derived classes. Definition at line 79 of file block_sparsity_pattern.h. For each locally owned cell, set the active finite element index to the corresponding value given in The vector Active FE indices will only be set for locally owned cells. Ghost and artificial cells will be ignored; no active FE index will be assigned to them. To exchange active FE indices on ghost cells, call distribute_dofs() afterwards. For each locally relevant cell, extract the active finite element index and fill the vector As we do not know the active FE index on artificial cells, they are set to the invalid value numbers::invalid_fe_index. For DoFHandler objects without hp-capabilities, the vector will consist of zeros, indicating that all cells use the same finite element. In hp-mode, the values may be different, though. The returned vector has as many entries as there are active cells. Return MPI communicator used by the underlying triangulation. Return the normal in a given quadrature point. The normal points in outwards direction as seen from the first cell of this interface. The same as above. The same as above. The same as above. Implementation of Arnold-Boffi-Falk (ABF) elements, conforming with the space Hdiv. These elements generate vector fields with normal components continuous between mesh cells. These elements are based on an article from Arnold, Boffi and Falk: Quadrilateral H(div) finite elements, SIAM J. Numer. Anal. Vol.42, No.6, pp.2429-2451 In this article, the authors demonstrate that the usual RT elements and also BDM and other proposed finite dimensional subspaces of H(div) do not work properly on arbitrary FE grids. I.e. the convergence rates deteriorate on these meshes. As a solution the authors propose the ABF elements, which are implemented in this class. This class is not implemented for the codimension one case ( The interpolation operators associated with the RT element are constructed such that interpolation and computing the divergence are commuting operations. We require this from interpolating arbitrary functions as well as the restriction matrices. It can be achieved by two interpolation schemes, the simplified one in FE_RaviartThomasNodal and the original one here: On edges or faces, the node values are the moments of the normal component of the interpolated function with respect to the traces of the RT polynomials. Since the normal trace of the RT space of degree k on an edge/face is the space Qk, the moments are taken with respect to this space. Higher order RT spaces have interior nodes. These are moments taken with respect to the gradient of functions in Qk on the cell (this space is the matching space for RTk in a mixed formulation). The Brezzi-Douglas-Marini element. The matching pressure space for FE_BDM of order k is the element FE_DGP of order k-1. The BDM element of order Additionally, for order greater or equal 2, we have additional p(p-1), the number of vector valued polynomials in Pp, interior degrees of freedom. These are the vector function values in the first p(p-1)/2 of the p2 Gauss points in the cell. Example classes are TensorProductPolynomials, PolynomialSpace or PolynomialsP. This class is not a fully implemented FiniteElement class. Instead there are several pure virtual functions declared in the FiniteElement and FiniteElement classes which cannot be implemented by this class but are left for implementation in derived classes. Definition at line 75 of file fe_poly.h. Remove and return the last element of the last range. This function throws an exception if the IndexSet is empty. Definition at line 561 of file index_set.cc. Remove and return the first element of the first range. This function throws an exception if the IndexSet is empty. Definition at line 579 of file index_set.cc. Definition at line 513 of file trilinos_tpetra_vector.h. Base class used to declare the operations needed by a concrete class implementing prolongation and restriction of vectors in the multigrid context. This class is abstract and has no implementation of these operations. There are several derived classes, reflecting the fact that vector types and numbering of the fine-grid discretization and of the multi-level implementation are independent. If you use multigrid for a single PDE or for your complete system of equations, you will use MGTransferPrebuilt together with Multigrid. The vector types used on the fine grid as well as for the multilevel operations may be Vector or BlockVector. In both cases, MGTransferPrebuilt will operate on all components of the solution. For mixed systems, it may be required to do multigrid only for a single component or for some components. The classes MGTransferSelect and MGTransferBlock handle these cases. MGTransferSelect is used if you use multigrid (on Vector objects) for a single component, possibly grouped using The class MGTransferBlock handles the case where your multigrid method operates on BlockVector objects. These can contain all or a consecutive set of the blocks of the complete system. Since most smoothers cannot operate on block structures, it is not clear whether this case is really useful. Therefore, a tested implementation of this case will be supplied when needed.
│ │ │ cell_will_be_refined
│ │ │ children_will_be_coarsened
│ │ │ -cell_invalid CELL_PERSIST
│ │ │ +
│ │ │ -CELL_PERSIST
│ │ │ CELL_REFINE
│ │ │ +
│ │ │ -CELL_REFINE
│ │ │ CELL_COARSEN
│ │ │ +
│ │ │ -CELL_COARSEN
│ │ │ CELL_INVALID
│ │ │ +
│ │ │
│ │ │
│ │ │ CELL_INVALID
│ │ │
│ │ │ inlineexplicit
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ AffineConstraints() [3/5]
│ │ │ @@ -879,15 +879,15 @@
│ │ │ const IndexSet &
│ │ │ locally_stored_constraints )
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ reinit() [3/3]
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ constraints_in with DoFs that are element of the IndexSet filter. Elements that are not present in the IndexSet are ignored. All DoFs will be transformed to local index space of the filter, both the constrained DoFs and the other DoFs these entries are constrained to. The local index space of the filter is a contiguous numbering of all (global) DoFs that are elements in the filter.[10,20), and the constraints object constraints_in includes the global indices {7,13,14}, the indices {3,4} are added to the calling constraints object (since 13 and 14 are elements in the filter and element 13 is the fourth element in the index, and 14 is the fifth).
│ │ │ +
│ │ │
│ │ │ ◆ add_constraint()
│ │ │
│ │ │ #include <deal.II/lac/block_sparsity_pattern.h>Detailed Description
│ │ │
│ │ │ class BlockSparsityPatternBase< SparsityPatternType >block(row,col) function.collect_sizes() function of this class! Note that, of course, all sub-matrices in a (block-)row have to have the same number of rows, and that all sub-matrices in a (block-)column have to have the same number of columns.
│ │ │ +
│ │ │
│ │ │
│ │ │ 
active_fe_indices.active_fe_indices needs to have as many entries as there are active cells. The FE indices must be in the order in which we iterate over active cells. Vector entries corresponding to active cells that are not locally owned are ignored.
│ │ │ +
│ │ │
│ │ │ ◆ get_active_fe_indices() [1/2]
│ │ │
│ │ │ active_fe_indices in the order in which we iterate over active cells. This vector is resized, if necessary.
│ │ │ +
│ │ │
│ │ │ ◆ set_future_fe_indices()
│ │ │
│ │ │ (
│ │ │ )
│ │ │ const
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ prepare_for_serialization_of_active_fe_indices()
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ )
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ dof_indices()
│ │ │
│ │ │ )
│ │ │ const
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │
│ │ │ 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. ◆ normal_vector()
│ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/classFEInterfaceViews_1_1Vector.html
│ │ │ @@ -572,15 +572,15 @@
│ │ │
│ │ │ )
│ │ │ const
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ jump_in_hessians()
│ │ │
│ │ │
│ │ │ )
│ │ │ const
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ jump_in_third_derivatives()
│ │ │
│ │ │
│ │ │ )
│ │ │ const
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_function_values()
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │ #include <deal.II/fe/fe_abf.h>Detailed Description
│ │ │
│ │ │ class FE_ABF< dim >spacedim != dim).
│ │ │ +
│ │ │ Interpolation
│ │ │ Node values on edges/faces
│ │ │ Interior node values
│ │ │ Generalized support points
│ │ │ @@ -2041,15 +2041,15 @@
│ │ │
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │ #include <deal.II/fe/fe_bdm.h>Detailed Description
│ │ │
│ │ │ class FE_BDM< dim >Degrees of freedom
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ p has p+1 degrees of freedom on each face. These are implemented as the function values in the p+1 Gauss points on each face.
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │ sp
│ │ │ 000023a0: 6163 6564 696d 2021 3d20 6469 6d3c 2f63 acedim != dim)..
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ 
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [2/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values() [1/2]
│ │ │
│ │ │
│ │ │ protectedvirtualinherited
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtual
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_subface_data()
│ │ │
│ │ │
│ │ │ protectedvirtual
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ fill_fe_subface_values()
│ │ │
│ │ │ (
│ │ │ )
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ pop_front()
│ │ │ @@ -1321,15 +1321,15 @@
│ │ │ (
│ │ │ )
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ get_index_vector()
│ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/classLinearAlgebra_1_1TpetraWrappers_1_1Vector.html
│ │ │ @@ -998,15 +998,15 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ )
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ import_elements() [3/3]
│ │ │
│ │ │
│ │ │ inline
│ │ │
│ │ │
│ │ │
│ │ │ +
│ │ │
│ │ │ ◆ operator()() [1/2]
│ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/classMGTransferBase.html
│ │ │ @@ -107,15 +107,15 @@
│ │ │ #include <deal.II/multigrid/mg_base.h>Detailed Description
│ │ │
│ │ │ class MGTransferBase< VectorType >
│ │ │ -
│ │ │ +
│ │ │ mg_target_component.
Here, the weights \(\text{JxW}_q\) of each quadrature point (where JxW mnemonically stands for Jacobian times Quadrature Weights) take the role of the \(dx\) in the original integral. Consequently, they appear in all code that computes integrals approximated by quadrature, and are accessed by FEValues::JxW().
│ │ │ -The transformation of vector fields or differential forms (gradients of scalar functions) \(\mathbf v\), and gradients of vector fields \(\mathbf T\) follows the general form
│ │ ││ │ │ \[ │ │ │ \mathbf v(\mathbf x) = \mathbf A(\hat{\mathbf x}) │ │ │ \hat{\mathbf v}(\hat{\mathbf x}), │ │ │ \qquad │ │ │ @@ -1073,15 +1073,15 @@ │ │ │ │ │ │ │ │ │
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
| [in] | input | An array (or part of an array) of input objects that should be mapped. |
| [in] | kind | The kind of mapping to be applied. |
| [in] | internal | A pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to. |
| [out] | output | An array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.) |
#include <deal.II/meshworker/simple.h>
Assemble local matrices into level matrices without using block structure.
│ │ │ -│ │ │ Public Member Functions | |
| MGMatrixSimple (double threshold=1.e-12) | |
│ │ │ Public Member Functions | |
| void | initialize (const BlockInfo *block_info, AnyData &residuals) |
The names of the input vectors. If this vector is nonempty, it can be used by application programs to automatically select and verify the input vectors used for integration.
│ │ │Definition at line 133 of file local_integrator.h.
│ │ │ │ │ │The names of the results produced. If this vector is nonempty, it can be used by application programs to automatically assign names to output values and/or verify the names of vectors.
│ │ │Definition at line 147 of file local_integrator.h.
│ │ │ │ │ │Delete the object pointed to and set the pointer to nullptr. Note that unlike what the documentation of the class describes, this function actually deletes the object pointed to. That is, this function assumes a ObserverPointer's ownership of the object pointed to.
│ │ │ -Definition at line 435 of file observer_pointer.h.
│ │ │ │ │ │This piece of code will first traverse all paths in the list set up for file class MESH. If it manages to open a file, it returns the istream object. If not, it will try to append the first suffix of the suffix list and do the same. And so on. If no file is found in the end, an exception is thrown.
If you want to restrict your search to a certain mesh format, .inp for instance, then either use "grid.inp" in the code above or use the alternative find(const std::string&,const std::string&,const char*) function
Path lists are by default starting with the current directory ("./"), followed optionally by a standard directory of deal.II. Use show() to find out the path list for a given class. Paths and suffixes can be added using the functions add_path() and add_suffix(), respectively.
"/", while suffixes should always start with a dot. These characters are not added automatically (allowing you to do some real file name editing).Definition at line 82 of file path_search.h.
│ │ ││ │ │ Public Types | ||
| enum | Position { back
│ │ │ , front
│ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/classSUNDIALS_1_1KINSOL.html
│ │ │ @@ -524,17 +524,17 @@
│ │ │
│ │ │
│ │ │ ├── html2text {}
│ │ │ │ @@ -367,16 +367,16 @@
│ │ │ │ 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 _K_I_N_S_O_L manual states this as follows: "The user should supply values
│ │ │ │ -\_form#2718, which are diagonal elements of the scaling matrix such that
│ │ │ │ -\_form#2734 has all components roughly the same magnitude when \_form#326 is
│ │ │ │ +\_form#2674, which are diagonal elements of the scaling matrix such that
│ │ │ │ +\_form#2710 has all components roughly the same magnitude when \_form#225 is
│ │ │ │ close to a solution".
│ │ │ │ If no function is provided to a _K_I_N_S_O_L object, then this is interpreted as
│ │ │ │ implicitly saying that all of these scaling factors should be considered as
│ │ │ │ one.
│ │ │ │ Note
│ │ │ │ This variable represents a _u_s_e_r_ _p_r_o_v_i_d_e_d_ _c_a_l_l_b_a_c_k. See there for a
│ │ │ │ description of how to deal with errors and other requirements and
│ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/classTrilinosWrappers_1_1MPI_1_1Vector.html
│ │ │ @@ -1270,15 +1270,15 @@
│ │ │ 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 \(0.000,000,003=3 \times 10^{-9}\) m/s, and pressures around \(10^9 \text{kg}/\text{m}/\text{s}^2\), i.e., vastly different. In such cases, computing the \(l_2\) 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#2718, │ │ │ -which are diagonal elements of the scaling matrix such that \_form#2734 has │ │ │ -all components roughly the same magnitude when \_form#326 is close to a │ │ │ + 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 \(0.000,000,003=3 \times 10^{-9}\) m/s, and pressures around \(10^9 \text{kg}/\text{m}/\text{s}^2\), i.e., vastly different. In such cases, computing the \(l_2\) 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#2674, │ │ │ +which are diagonal elements of the scaling matrix such that \_form#2710 has │ │ │ +all components roughly the same magnitude when \_form#225 is close to a │ │ │ solution". │ │ │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. │ │ │
| |
Definition at line 767 of file trilinos_vector.h.
│ │ │ │ │ │Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Implements Utilities::MPI::ConsensusAlgorithms::Interface< RequestType, AnswerType >.
│ │ │ │ │ │Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Implements Utilities::MPI::ConsensusAlgorithms::Interface< RequestType, AnswerType >.
│ │ │ │ │ │Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
| RequestType | The type of the elements of the vector to sent. |
| AnswerType | The type of the elements of the vector to received. |
Definition at line 164 of file mpi_consensus_algorithms.h.
│ │ ││ │ │ Public Member Functions | |
| virtual | ~Process ()=default |
Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Implements Utilities::MPI::ConsensusAlgorithms::Interface< RequestType, AnswerType >.
│ │ │ │ │ │Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Implements Utilities::MPI::ConsensusAlgorithms::Interface< RequestType, AnswerType >.
│ │ │ │ │ │Run the consensus algorithm and return a vector of process ranks that have requested answers from the current process.
│ │ │This version of the run() function simply unpacks the functions packaged in process and calls the version of the run() function that takes a number of std::function arguments.
Definition at line 61 of file mpi_remote_point_evaluation.cc.
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │std::map instead. std::map instead. std::map instead. std::map instead. std_cxx20::type_identity instead. Simplified interface for loop() if specialized for integration, using the virtual functions in LocalIntegrator.
│ │ │ -vtu: .vtu svg: .svg deal_II_intermediate: .d2. Definition at line 2504 of file data_out_base.cc.
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │Same as above.
│ │ │ - │ │ │ + │ │ │ │ │ │Definition at line 1556 of file dof_tools.cc.
│ │ │ │ │ │Same as above.
│ │ │ - │ │ │ + │ │ │ │ │ │Definition at line 1582 of file dof_tools.cc.
│ │ │ │ │ │Extract the set of global DoF indices that are active on the current DoFHandler. For regular DoFHandlers, these are all DoF indices, but for DoFHandler objects built on parallel::distributed::Triangulation this set is a superset of DoFHandler::locally_owned_dofs() and contains all DoF indices that live on all locally owned cells (including on the interface to ghost cells). However, it does not contain the DoF indices that are exclusively defined on ghost or artificial cells (see the glossary).
│ │ │The degrees of freedom identified by this function equal those obtained from the dof_indices_with_subdomain_association() function when called with the locally owned subdomain id.
│ │ │ -Definition at line 1107 of file dof_tools.cc.
│ │ │ │ │ │Same function as above but for a certain (multigrid-)level. This function returns all DoF indices that live on all locally owned cells (including on the interface to ghost cells) on the given level.
│ │ │ -Definition at line 1154 of file dof_tools.cc.
│ │ │ │ │ │Extract the set of global DoF indices that are active on the current DoFHandler. For regular DoFHandlers, these are all DoF indices, but for DoFHandler objects built on parallel::distributed::Triangulation this set is the union of DoFHandler::locally_owned_dofs() and the DoF indices on all ghost cells. In essence, it is the DoF indices on all cells that are not artificial (see the glossary).
│ │ │ -Definition at line 1204 of file dof_tools.cc.
│ │ │ │ │ │Same as extract_locally_relevant_dofs() but for multigrid DoFs for the given level.
Definition at line 1260 of file dof_tools.cc.
│ │ │ │ │ │For each active cell of a DoFHandler, extract the active finite element index and fill the vector given as second argument. This vector is assumed to have as many entries as there are active cells.
│ │ │For DoFHandler objects without hp-capabilities given as first argument, the returned vector will consist of only zeros, indicating that all cells use the same finite element. In hp-mode, the values may be different, though.
│ │ │As we do not know the active FE index on artificial cells, we set them to the invalid value numbers::invalid_fe_index.
│ │ │ -Definition at line 1679 of file dof_tools.cc.
│ │ │ │ │ │A version of the function of same name that returns the map via its third argument. This function is deprecated.
std::map instead. A version of the function of same name that returns the map via its third argument. This function is deprecated.
std::map instead. Definition at line 2617 of file dof_tools.cc.
│ │ │ │ │ │A version of the function of same name that returns the map via its third argument. This function is deprecated.
std::map instead. A version of the function of same name that returns the map via its third argument. This function is deprecated.
std::map instead. Definition at line 2638 of file dof_tools.cc.
│ │ │ │ │ │This is the opposite function to the one above. It generates a map where the keys are the support points of the degrees of freedom, while the values are the DoF indices. For a definition of support points, see this glossary entry.
│ │ │Since there is no natural order in the space of points (except for the 1d case), you have to provide a map with an explicitly specified comparator object. This function is therefore templatized on the comparator object. Previous content of the map object is deleted in this function.
│ │ │Just as with the function above, it is assumed that the finite element in use here actually supports the notion of support points of all its components.
│ │ │ -Same as above but for a specific number of sub-elements.
│ │ │ -Take a FiniteElement object and return a boolean vector describing the restriction_is_additive_flags (see the documentation of the FiniteElement class) for each shape function of the mixed element consisting of N1, N2, ... copies of the sub-elements fe1, fe2, ...
The "restriction is additive" flags are properties of individual shape functions that do not depend on whether the composed element uses the tensor product or combination strategy outlined in the documentation of the FETools::Composition namespace. Consequently, this function does not have a do_tensor_product argument.
Compute the non-zero vector components of a composed finite element. This function is similar to the previous one, except that the pointers indicate the elements to be composed, and the arguments N1, N2, ... the multiplicities. Null pointers indicate that an argument is to be skipped.
If do_tensor_product is true, the number of components (and thus the size of the ComponentMask objects) is the sum over the product of the number of components in each of the finite elements times the corresponding multiplicity. Otherwise the number of components is taken from the first finite element with non-zero multiplicity, and all other elements with non-zero multiplicities need to have the same number of vector components.
See the documentation of namespace FETools::Compositing for more information about the do_tensor_product argument.
Given a triangulation and a list of cells whose children have become distorted as a result of mesh refinement, try to fix these cells up by moving the center node around.
│ │ │The function returns a list of cells with distorted children that couldn't be fixed up for whatever reason. The returned list is therefore a subset of the input argument.
│ │ │For a definition of the concept of distorted cells, see the glossary entry. The first argument passed to the current function is typically the exception thrown by the Triangulation::execute_coarsening_and_refinement function.
│ │ │ -Definition at line 2754 of file grid_tools.cc.
│ │ │ │ │ │The residual of the divergence operator in weak form.
│ │ │ \[ - \int_Z │ │ │ \nabla v \cdot \mathbf u \,dx \] │ │ │
│ │ │This is the weak divergence operator and the test space should be at least H1. The trial functions may be discontinuous.
│ │ │ -Definition at line 125 of file divergence.h.
│ │ │ │ │ │The residual of the gradient operator in weak form.
│ │ │ \[ -\int_Z │ │ │ \nabla\cdot \mathbf v u \,dx \] │ │ │
│ │ │This is the weak gradient operator and the test space should be at least Hdiv. The trial functions may be discontinuous.
│ │ │ -Definition at line 229 of file divergence.h.
│ │ │ │ │ │| using parallel::distributed::SolutionTransfer = typedef ::SolutionTransfer<dim, VectorType, spacedim> | │ │ │
Definition at line 33 of file solution_transfer.h.
│ │ │ │ │ │| using types::geometric_entity_type = typedef std::uint8_t | │ │ │
The type used to denote geometric entity types.
│ │ │ -| using SmartPointer = ObserverPointer<T, P> | │ │ │
A type alias for the ObserverPointer class that makes sure the previous name of the class, SmartPointer, continues to be available.
│ │ │ -Definition at line 285 of file observer_pointer.h.
│ │ │ │ │ │The same trick with the mixed system does not work here, because we would end up with both Dirichlet and Neumann boundary conditions for \(u\), but none for \(v\).
│ │ │The solution to this conundrum arrived with the Discontinuous Galerkin method wave in the 1990s and early 2000s: In much the same way as one can use discontinuous shape functions for the Laplace equation by penalizing the size of the discontinuity to obtain a scheme for an equation that has one derivative on each shape function, we can use a scheme that uses continuous (but not \(C^1\) continuous) shape functions and penalize the jump in the derivative to obtain a scheme for an equation that has two derivatives on each shape function. In analogy to the Interior Penalty (IP) method for the Laplace equation, this scheme for the biharmonic equation is typically called the \(C^0\) IP (or C0IP) method, since it uses \(C^0\) (continuous but not continuously differentiable) shape functions with an interior penalty formulation.
│ │ │It is worth noting that the C0IP method is not the only one that has been developed for the biharmonic equation. step-82 shows an alternative method.
│ │ │We base this program on the \(C^0\) IP method presented by Susanne Brenner and Li-Yeng Sung in the paper " \_form#1217 Interior Penalty Method │ │ │ +
We base this program on the \(C^0\) IP method presented by Susanne Brenner and Li-Yeng Sung in the paper " \_form#1270 Interior Penalty Method │ │ │ for Linear Fourth Order Boundary Value Problems on polygonal │ │ │ domains" [Brenner2005] where the method is derived for the biharmonic equation with "clamped" boundary conditions.
│ │ │As mentioned, this method relies on the use of \(C^0\) Lagrange finite elements where the \(C^1\) continuity requirement is relaxed and has been replaced with interior penalty techniques. To derive this method, we consider a \(C^0\) shape function \(v_h\) which vanishes on \(\partial\Omega\). We introduce notation \( \mathbb{F} \) as the set of all faces of \(\mathbb{T}\), \( \mathbb{F}^b \) as the set of boundary faces, and \( \mathbb{F}^i \) as the set of interior faces for use further down below. Since the higher order derivatives of \(v_h\) have two values on each interface \(e\in \mathbb{F}\) (shared by the two cells \(K_{+},K_{-} \in \mathbb{T}\)), we cope with this discontinuity by defining the following single-valued functions on \(e\):
│ │ │ \begin{align*} │ │ │ \jump{\frac{\partial^k v_h}{\partial \mathbf n^k}} │ │ │ &= │ │ │ \frac{\partial^k v_h|_{K_+}}{\partial \mathbf n^k} \bigg |_e │ │ │ ├── html2text {} │ │ │ │ @@ -174,15 +174,15 @@ │ │ │ │ (C^0\) IP (or C0IP) method, since it uses \(C^0\) (continuous but not │ │ │ │ continuously differentiable) shape functions with an interior penalty │ │ │ │ formulation. │ │ │ │ It is worth noting that the C0IP method is not the only one that has been │ │ │ │ developed for the biharmonic equation. _s_t_e_p_-_8_2 shows an alternative method. │ │ │ │ ******** DDeerriivvaattiioonn ooff tthhee CC00IIPP mmeetthhoodd ******** │ │ │ │ We base this program on the \(C^0\) IP method presented by Susanne Brenner and │ │ │ │ -Li-Yeng Sung in the paper " \_form#1217 Interior Penalty Method for Linear │ │ │ │ +Li-Yeng Sung in the paper " \_form#1270 Interior Penalty Method for Linear │ │ │ │ Fourth Order Boundary Value Problems on polygonal domains" [[BBrreennnneerr22000055]] where │ │ │ │ the method is derived for the biharmonic equation with "clamped" boundary │ │ │ │ conditions. │ │ │ │ As mentioned, this method relies on the use of \(C^0\) Lagrange finite elements │ │ │ │ where the \(C^1\) continuity requirement is relaxed and has been replaced with │ │ │ │ interior penalty techniques. To derive this method, we consider a \(C^0\) shape │ │ │ │ function \(v_h\) which vanishes on \(\partial\Omega\). We introduce notation \ │ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/step_58.html │ │ │ @@ -568,16 +568,16 @@ │ │ │ \left(\psi^{(n,2)}+\psi^{(n,1)}\right)\right] │ │ │ + │ │ │ V \left[\frac 12 \left(\psi^{(n,2)}+\psi^{(n,1)}\right)\right] = 0. │ │ │ \end{align*} │ │ │
│ │ │Here, the "previous" solution \(\psi^{(n,1)}\) (or the "initial │ │ │ condition" for this part of the time step) is the output of the first phase rotation half-step; the output of the current step will be denoted by \(\psi^{(n,2)}\). \(k_{n+1}=t_{n+1}-t_n\) is the length of the time step. (One could argue whether \(\psi^{(n,1)}\) and \(\psi^{(n,1)}\) live at time step \(n\) or \(n+1\) and what their upper indices should be. This is a philosophical discussion without practical impact, and one might think of \(\psi^{(n,1)}\) as something like \(\psi^{(n+\tfrac 13)}\), and \(\psi^{(n,2)}\) as \(\psi^{(n+\tfrac 23)}\) if that helps clarify things – though, again \(n+\frac 13\) is not to be understood as "one third time step after │ │ │ - \_form#455" but more like "we've already done one third of the work necessary │ │ │ -for time step \_form#3370".)
│ │ │ + \_form#397" but more like "we've already done one third of the work necessary │ │ │ +for time step \_form#3201".) │ │ │If we multiply the whole equation with \(k_{n+1}\) and sort terms with the unknown \(\psi^{(n+1,2)}\) to the left and those with the known \(\psi^{(n,2)}\) to the right, then we obtain the following (spatial) partial differential equation that needs to be solved in each time step:
│ │ │ \begin{align*} │ │ │ -i\psi^{(n,2)} │ │ │ - │ │ │ \frac 14 k_{n+1} \Delta \psi^{(n,2)} │ │ │ + │ │ │ \frac 12 k_{n+1} V \psi^{(n,2)} │ │ │ ├── html2text {} │ │ │ │ @@ -378,16 +378,16 @@ │ │ │ │ step; the output of the current step will be denoted by \(\psi^{(n,2)}\). \(k_ │ │ │ │ {n+1}=t_{n+1}-t_n\) is the length of the time step. (One could argue whether \ │ │ │ │ (\psi^{(n,1)}\) and \(\psi^{(n,1)}\) live at time step \(n\) or \(n+1\) and │ │ │ │ what their upper indices should be. This is a philosophical discussion without │ │ │ │ practical impact, and one might think of \(\psi^{(n,1)}\) as something like \ │ │ │ │ (\psi^{(n+\tfrac 13)}\), and \(\psi^{(n,2)}\) as \(\psi^{(n+\tfrac 23)}\) if │ │ │ │ that helps clarify things – though, again \(n+\frac 13\) is not to be │ │ │ │ -understood as "one third time step after \_form#455" but more like "we've │ │ │ │ -already done one third of the work necessary for time step \_form#3370".) │ │ │ │ +understood as "one third time step after \_form#397" but more like "we've │ │ │ │ +already done one third of the work necessary for time step \_form#3201".) │ │ │ │ If we multiply the whole equation with \(k_{n+1}\) and sort terms with the │ │ │ │ unknown \(\psi^{(n+1,2)}\) to the left and those with the known \(\psi^{ │ │ │ │ (n,2)}\) to the right, then we obtain the following (spatial) partial │ │ │ │ differential equation that needs to be solved in each time step: │ │ │ │ \begin{align*} -i\psi^{(n,2)} - \frac 14 k_{n+1} \Delta \psi^{(n,2)} + \frac 12 │ │ │ │ k_{n+1} V \psi^{(n,2)} = -i\psi^{(n,1)} + \frac 14 k_{n+1} \Delta \psi^{(n,1)} │ │ │ │ - \frac 12 k_{n+1} V \psi^{(n,1)}. \end{align*} │ │ ├── ./usr/share/doc/libdeal.ii-doc/html/doxygen/deal.II/todo.html │ │ │ @@ -100,79 +100,79 @@ │ │ │
mapping argument should be replaced by a hp::MappingCollection in case of a DoFHandler with hp-capabilities. The 3d version exhibits some numerical instabilities, in particular for higher order
│ │ │ -Restriction matrices are missing.
│ │ │ +Restriction matrices are missing.
│ │ │ +The 3d version exhibits some numerical instabilities, in particular for higher order
│ │ │elide_zero_values is currently ignored. elide_zero_values is currently ignored. elide_zero_values is currently ignored. elide_zero_values is currently ignored.