Emily Boudreaux
6b57738330
Note for now much of the docs is LLM written. This was done to save time and focus on code development. The docs have been LOOSLEY reviewed. However, the code itself has been either fully written by hand or fully reviewed. Therefore, the docs should at the moment be seen as a loose resource rather than authoratiative (and this is on top of the general ability for docs to drift)
1045 lines
76 KiB
Groff
1045 lines
76 KiB
Groff
.TH "serif::operators::backend::mfem" 3 "Version v0.0.1a" "SERiF" \" -*- nroff -*-
|
|
.ad l
|
|
.nh
|
|
.SH NAME
|
|
serif::operators::backend::mfem
|
|
.SH SYNOPSIS
|
|
.br
|
|
.PP
|
|
.SS "Namespaces"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "namespace \fBdetail\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "namespace \fBvolume_keys\fP"
|
|
.br
|
|
.in -1c
|
|
.SS "Classes"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "struct \fBBasisBindings\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "class \fBBasisEvaluation\fP"
|
|
.br
|
|
.RI "Represents an element-local basis evaluation operator, supporting dense or tensor contractions, pointwise mappings, and transpose application\&. "
|
|
.ti -1c
|
|
.RI "struct \fBBasisWorkspace\fP"
|
|
.br
|
|
.RI "Reusable scratch storage for basis contractions, reducing repeated allocations\&. "
|
|
.ti -1c
|
|
.RI "struct \fBClosure\fP"
|
|
.br
|
|
.RI "A minimal density-valued volume equation, sufficient to instantiate a volume cache\&. "
|
|
.ti -1c
|
|
.RI "struct \fBCoefficientTracking\fP"
|
|
.br
|
|
.RI "Track coefficient values using an owned snapshot and the identity of their binding\&. "
|
|
.ti -1c
|
|
.RI "struct \fBCoefficientView\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBCompactificationCoefficients\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBContributionData\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBDisplacementCoefficients\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBElementBasis\fP"
|
|
.br
|
|
.RI "Fixed-mesh basis samples; independent of the current coefficient values and displacement\&. "
|
|
.ti -1c
|
|
.RI "struct \fBElementData\fP"
|
|
.br
|
|
.RI "Weighted equation data retains the exact basis, geometry, and samples used to compute it\&. "
|
|
.ti -1c
|
|
.RI "struct \fBElementGeometry\fP"
|
|
.br
|
|
.RI "Physical mapping and mapped bases for one frozen displacement\&. "
|
|
.ti -1c
|
|
.RI "class \fBJacobianOperator\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "class \fBLinearizedBlock\fP"
|
|
.br
|
|
.RI "An accepted physical block with optional efficient diagonal and sparse assembly operations\&. "
|
|
.ti -1c
|
|
.RI "struct \fBMappingCoefficients\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBMetadataTracking\fP"
|
|
.br
|
|
.RI "Validate external mesh resources before the graph compares their metadata\&. "
|
|
.ti -1c
|
|
.RI "struct \fBNumericalWork\fP"
|
|
.br
|
|
.RI "Numerical work derived from the dependency engine's most recent report\&. "
|
|
.ti -1c
|
|
.RI "struct \fBOperandEvaluator\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "struct \fBOperandEvaluator< OperandT >\fP"
|
|
.br
|
|
.RI "Scalar and vector H1 gradients share the existing value/divergence coefficient contractions\&. "
|
|
.ti -1c
|
|
.RI "struct \fBOperandSamples\fP"
|
|
.br
|
|
.RI "Reference samples remain available for derivatives through the physical mapping\&. "
|
|
.ti -1c
|
|
.RI "struct \fBPreparationRejection\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "class \fBTensorBasisCache\fP"
|
|
.br
|
|
.RI "Share immutable tensor plans within one operator; copied rules are keyed by their contents\&. "
|
|
.ti -1c
|
|
.RI "struct \fBVolumeConfiguration\fP"
|
|
.br
|
|
.RI "Stable equation ownership also retains temporary and move-only contribution trees\&. "
|
|
.ti -1c
|
|
.RI "struct \fBVolumeData\fP"
|
|
.br
|
|
.RI "One accepted result contains ordered contribution batches and the assembled residual\&. "
|
|
.ti -1c
|
|
.RI "struct \fBVolumeDiscretization\fP"
|
|
.br
|
|
.RI "Borrowed discretization objects must outlive their graph and its accepted results\&. "
|
|
.ti -1c
|
|
.RI "struct \fBVolumeOptions\fP"
|
|
.br
|
|
.RI "Numerical choices fixed when the graph is constructed\&. "
|
|
.ti -1c
|
|
.RI "struct \fBVolumeScratch\fP"
|
|
.br
|
|
.RI "Scratch belongs to graph callables and is never a dependency source\&. "
|
|
.ti -1c
|
|
.RI "struct \fBWorkspace\fP"
|
|
.br
|
|
.RI "Reusable scratch for applying the accepted element linearization\&. "
|
|
.in -1c
|
|
.SS "Concepts"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "concept \fBClosureResult\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "concept \fBClosureInputsAccept\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "concept \fBEvaluableOperand\fP"
|
|
.br
|
|
.RI "Check the complete interface used by preparation, Jacobian application, and its transpose\&. "
|
|
.in -1c
|
|
.SS "Typedefs"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "using \fBSchema\fP = \fBdiscretization::domain::schema::CoreEnvelopeVacuumDomainSchema\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBDensity\fP = \fBdiscretization::forms::Operand\fP<\fBdiscretization::blocks::density::mass\fP>"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBDensityBinding\fP = \fBdiscretization::backend::mfem::TermBinding\fP<\fBClosure::Test\fP, \fBSchema\fP>"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBVector\fP = ::mfem::Vector"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBVolumeCoefficients\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBVolumeMesh\fP = \fBVolumeDiscretization\fP<\fBClosure::Test\fP, \fBSchema\fP>"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBVolumeInputs\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBVolumeCache\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBMatrixAction\fP = std::function<void(const \fB::mfem::Vector\fP&, \fB::mfem::Vector\fP&)>"
|
|
.br
|
|
.ti -1c
|
|
.RI "using \fBMatrixArrayAction\fP = std::function<void(std::span<const \fB::mfem::Vector\fP* const>, std::span<\fB::mfem::Vector\fP* const>)>"
|
|
.br
|
|
.RI "Apply the forward action to several directions at once (zeroed outputs, as \fBMatrixAction\fP receives)\&. "
|
|
.ti -1c
|
|
.RI "using \fBPreparationMode\fP = \fButils::dependencies::PreparationMode\fP"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<std::size_t Contribution, typename OperandT, typename Scope = void> using \fBVolumeOperandResult\fP"
|
|
.br
|
|
.RI "Values need a mapping node only when the operand's physical representation depends on geometry\&. "
|
|
.ti -1c
|
|
.RI "template<typename CacheT, typename Scope = void> using \fBVolumeEquationOf\fP = typename std::remove_cvref_t<decltype(std::declval<const CacheT&>()\&.template get<typename \fBvolume_keys::Scoped\fP<Scope>::Linearization>())>::Equation"
|
|
.br
|
|
.RI "Recover the equation type from a cache's accepted result type, without accessing a result\&. "
|
|
.ti -1c
|
|
.RI "template<typename ElementT> using \fBElementBatch\fP = std::vector<std::shared_ptr<const ElementT>>"
|
|
.br
|
|
.RI "A stage owns immutable element results, shared with downstream stages and accepted linearizations\&. "
|
|
.ti -1c
|
|
.RI "using \fBMeshAndCoefficientBindings\fP = \fBvolume_keys::Scoped\fP<void>::Bindings"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<typename OperandT> using \fBSamplesFor\fP = \fBOperandSamples\fP"
|
|
.br
|
|
.RI "Associate an operand type pack with equally ordered sample arguments\&. "
|
|
.in -1c
|
|
.SS "Enumerations"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "enum class \fBPreparationRejectionReason\fP { \fBMAPPING\fP, \fBEQUATION\fP, \fBNON_FINITE\fP }"
|
|
.br
|
|
.ti -1c
|
|
.RI "enum class \fBContractionMode\fP "
|
|
.br
|
|
.RI "Options enum to control how the tensor contractions are performed\&. "
|
|
.ti -1c
|
|
.RI "enum class \fBReferenceOperation\fP "
|
|
.br
|
|
.RI "Options enum to control what is actually evaluated at the reference points\&. "
|
|
.ti -1c
|
|
.RI "enum class \fBContractionMode\fP "
|
|
.br
|
|
.RI "Options enum to control how the tensor contractions are performed\&. "
|
|
.in -1c
|
|
.SS "Functions"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "template<typename BindingT> \fBCoefficientView\fP< BindingT > \fBbind\fP (const BindingT &binding, const \fB::mfem::Vector\fP &\fBvalues\fP)"
|
|
.br
|
|
.RI "Borrow a term binding and its coefficients without extending their lifetimes\&. "
|
|
.ti -1c
|
|
.RI "template<typename BindingT> void \fBbind\fP (const BindingT &, \fB::mfem::Vector\fP &&)=delete"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<typename BindingT> void \fBbind\fP (const BindingT &, const \fB::mfem::Vector\fP &&)=delete"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<typename BindingT> void \fBbind\fP (const BindingT &&, const \fB::mfem::Vector\fP &)=delete"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<typename\&.\&.\&. BindingTs> auto \fBmake_term_coefficients\fP (BindingTs\&.\&.\&. bindings)"
|
|
.br
|
|
.RI "Associate each physical term with its bound coefficients in an ordinary dependency context\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBlinearized_action\fP (int rows, int columns, \fBMatrixAction\fP action, \fBMatrixAction\fP transpose)"
|
|
.br
|
|
.RI "Wrap owned callbacks with checked dimensions, finite results, and overlap-safe application\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBlinearized_action\fP (int rows, int columns, \fBMatrixAction\fP action, \fBMatrixAction\fP transpose, \fBMatrixArrayAction\fP batch)"
|
|
.br
|
|
.RI "As above, with a batched forward action used by the operator's ArrayMult\&. "
|
|
.ti -1c
|
|
.RI "void \fBapply_many\fP (const ::mfem::Operator &action, std::span< const \fB::mfem::Vector\fP *const > inputs, std::span<\fB::mfem::Vector\fP *const > outputs)"
|
|
.br
|
|
.RI "Apply an operator to several directions; ArrayMult for SERiF actions, otherwise one Mult per direction\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBtranspose_block\fP (\fBLinearizedBlock\fP block)"
|
|
.br
|
|
.RI "Transpose a linearized block without discarding efficient assembly and diagonal operations\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBcompose_blocks\fP (\fBLinearizedBlock\fP left, \fBLinearizedBlock\fP right)"
|
|
.br
|
|
.RI "Compose linearized blocks in their written mathematical order\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBsum_blocks\fP (int rows, int columns, std::vector< \fBLinearizedBlock\fP > blocks)"
|
|
.br
|
|
.RI "Sum compatible linearized blocks while retaining their native diagonal and sparse assembly operations\&. "
|
|
.ti -1c
|
|
.RI "template<typename ContributionT, std::size_t Count> void \fBelement_residual\fP (const \fBElementData\fP< Count > &data, \fB::mfem::Vector\fP &result, \fBBasisWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Integrate the cached scalar/vector physics against its actual test operation\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT, bool Fields, bool Geometry> void \fBfinish_element_action\fP (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > &data, const ::mfem::DenseMatrix &geometry_derivatives, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Finish an element action from its field part (workspace\&.quadrature_values) and, with Geometry, the displacement samples (workspace\&.displacement_samples): contract the geometry derivatives and integrate\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT, bool Fields = true, bool Geometry = true> void \fBelement_jacobian_action\fP (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > &data, const ::mfem::DenseMatrix &geometry_derivatives, const std::array< \fBdiscretization::backend::mfem::DofMap::Elements\fP, \fBEquationPlan\fP< EquationT >::column_count > &columns, const std::array< const \fB::mfem::Vector\fP *, \fBEquationPlan\fP< EquationT >::column_count > &directions, const \fBdiscretization::backend::mfem::DofMap::Elements\fP &displacement_binding, const \fB::mfem::Vector\fP &displacement_direction, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Apply the accepted field derivatives and local displacement derivatives\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> void \fBelement_geometry_actions\fP (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > &data, const ::mfem::DenseMatrix &geometry_derivatives, const \fBdiscretization::backend::mfem::DofMap::Elements\fP &displacement_binding, std::span< const \fB::mfem::Vector\fP *const > displacement_directions, \fBWorkspace\fP &workspace, std::span<\fB::mfem::Vector\fP *const > results)"
|
|
.br
|
|
.RI "element_jacobian_action<false, true> for several displacement directions of one element\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > \fBsample_element_basis\fP (const ContributionT &equation, int element, const \fBdiscretization::backend::mfem::DofMap\fP &row, const \fBdiscretization::backend::mfem::DofMap\fP &displacement_binding, const std::array< const \fBdiscretization::backend::mfem::DofMap\fP *, \fBEquationPlan\fP< EquationT >::column_count > &columns, const \fBmapping::DomainMapper\fP &mapper, const \fBdiscretization::quadrature::Policy\fP &policy, \fBTensorBasisCache\fP &basis_cache, \fBContractionMode\fP contraction_mode)"
|
|
.br
|
|
.RI "Sample the contribution's quadrature rule and bases on the fixed computational mesh\&. "
|
|
.ti -1c
|
|
.RI "elements \fBelement_values\fP (basis\&.element, input\&.values, workspace\&.element_values)"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > \fBmap_element_geometry\fP (const \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > &basis, const \fBdiscretization::backend::mfem::DofMap\fP &displacement_binding, const \fBdiscretization::backend::mfem::DofMap::Elements\fP &displacement_elements, const \fB::mfem::Vector\fP &displacement, const \fBMappingCoefficients\fP &compactification, const \fBmapping::DomainMapper\fP &mapper, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Freeze displacement and compactification, then map quadrature points and bases to physical space\&. "
|
|
.ti -1c
|
|
.RI "template<EvaluableOperand OperandT, std::size_t Count> \fB::mfem::Vector\fP \fBmap_element_operand\fP (const \fB::mfem::Vector\fP &reference, const \fBElementGeometry\fP< Count > &geometry, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Apply an operand's physical transformation to its cached fixed-mesh samples\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> \fBequations::EquationPoint\fP< typename ContributionT::Operands > \fBelement_equation_point\fP (const std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > &physical_values, const \fBmapping::MappingPointContext\fP &context, int point)"
|
|
.br
|
|
.RI "Pack the physical samples requested by this contribution at one quadrature point\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> bool \fBstore_element_linearization\fP (const \fBequations::PointLinearization\fP< typename ContributionT::Operands, typename \fBOperandEvaluator\fP< \fBequations::TestOperandOf\fP< ContributionT > >::Value > &physics, int point, double weight, \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > &data)"
|
|
.br
|
|
.RI "Weight a point's residual and derivatives; reject any non-finite stored component\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > \fBevaluate_element_equation\fP (const ContributionT &equation, double coefficient, std::shared_ptr< const \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > basis, std::shared_ptr< const \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > > geometry, std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > reference_values, const std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > &physical_values, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Evaluate and weight the equation while retaining its immutable preparation inputs\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT> void \fBelement_jacobian_transpose\fP (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > &data, const ::mfem::DenseMatrix &geometry_derivatives, const \fBdiscretization::backend::mfem::DofMap::Elements\fP &row, const \fB::mfem::Vector\fP &residual_dual, \fBWorkspace\fP &workspace, std::array<\fB::mfem::Vector\fP, \fBEquationPlan\fP< EquationT >::column_count > &column_duals, \fB::mfem::Vector\fP &displacement_dual)"
|
|
.br
|
|
.RI "Transpose the same accepted field and geometry contractions used by the forward action\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation Equation, typename Contribution> auto \fBgeometry_integrand_variation\fP (const \fBElementData\fP< \fBEquationPlan\fP< Equation >::operand_count > &data, int point, const \fBmapping::VolumeMappingContext\fP &context, const \fBmapping::VolumeMappingVariation\fP &variation)"
|
|
.br
|
|
.RI "Differentiate the weighted physics through position, operand mappings and the volume measure\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation Equation, typename Contribution> std::expected<::mfem::DenseMatrix, \fBPreparationRejection\fP > \fBelement_geometry_derivatives\fP (const \fBElementData\fP< \fBEquationPlan\fP< Equation >::operand_count > &data, const \fBdiscretization::backend::mfem::DofMap\fP &displacement_binding, const ::mfem::FiniteElementSpace &compactification_space, const \fBmapping::DomainMapper\fP &mapper, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Differentiate one weighted integrand with respect to local displacement values and gradients\&. "
|
|
.ti -1c
|
|
.RI "std::vector< double > \fBchecked_diagonal\fP (const \fBLinearizedBlock\fP &block)"
|
|
.br
|
|
.RI "Extract a diagonal and reject a callback that violates its declared physical block dimensions\&. "
|
|
.ti -1c
|
|
.RI "std::shared_ptr< const ::mfem::SparseMatrix > \fBchecked_assembly\fP (const \fBLinearizedBlock\fP &block)"
|
|
.br
|
|
.RI "Assemble a non-null finalized sparse matrix whose dimensions match its declared physical action\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBlinearized_block\fP (std::shared_ptr< const ::mfem::SparseMatrix > matrix)"
|
|
.br
|
|
.RI "Retain an already assembled physical block without copying its matrix\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBlinearized_block\fP (std::shared_ptr< const ::mfem::DenseMatrix > matrix)"
|
|
.br
|
|
.RI "Retain a small assembled physical block, such as a generated scalar constraint\&. "
|
|
.ti -1c
|
|
.RI "template<typename CacheT, typename PrepareT> std::expected< void, \fBPreparationRejection\fP > \fBtry_prepare_validated\fP (CacheT &cache, PrepareT &&prepare)"
|
|
.br
|
|
.RI "A failed validation or calculation must make the previous accepted result inaccessible\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation RowEquationT, typename ContributionT> const ::mfem::IntegrationRule & \fBequation_rule\fP (const ContributionT &equation, const \fBdiscretization::quadrature::Policy\fP &policy, ::mfem::ElementTransformation &transformation, const ::mfem::FiniteElement &displacement_element, \fBdiscretization::quadrature::MappingKind\fP mapping_kind=\fBdiscretization::quadrature::MappingKind::general\fP, int reconstruction_order=0)"
|
|
.br
|
|
.RI "Resolve one rule covering all operand forms and the geometry weight\&. "
|
|
.ti -1c
|
|
.RI "\fBLinearizedBlock\fP \fBreplace_block_rows\fP (\fBLinearizedBlock\fP original, std::vector< int > selected_rows, std::shared_ptr< const ::mfem::SparseMatrix > replacement)"
|
|
.br
|
|
.RI "Replace selected physical equation rows with an immutable sparse row block in the same unknown coordinates\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> void \fBvalidate_volume_data\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data)"
|
|
.br
|
|
.RI "Reject changes to discretization objects borrowed by an accepted linearization\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename VisitT> void \fBfor_each_volume_element\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, VisitT &&visit)"
|
|
.br
|
|
.RI "Visit each contribution's own batch in equation order, without scanning other contributions\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename VisitT> void \fBfor_each_volume_linearization\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, VisitT &&visit)"
|
|
.br
|
|
.RI "Visit equation data together with its graph-owned local geometry derivative matrix\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> int \fBvolume_height\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data)"
|
|
.br
|
|
.RI "Return the supported residual size\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> int \fBvolume_width\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data)"
|
|
.br
|
|
.RI "Packed directions contain unique coefficient terms followed by displacement\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> std::size_t \fBtensor_element_count\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data)"
|
|
.br
|
|
.RI "Count contribution-elements using tensor contractions for any sampled basis\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> int \fBintegration_order\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, int element)"
|
|
.br
|
|
.RI "Return the largest contribution quadrature order on a supported mesh element\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> void \fBvolume_residual\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Copy the residual already assembled and checked when this result was accepted\&. "
|
|
.ti -1c
|
|
.RI "template<std::size_t Count> std::array< \fBdiscretization::backend::mfem::DofMap::Elements\fP, Count > \fBcolumn_elements\fP (const std::array< const \fBdiscretization::backend::mfem::DofMap\fP *, Count > &columns)"
|
|
.br
|
|
.RI "Validate coefficient bindings once before a complete element traversal\&. "
|
|
.ti -1c
|
|
.RI "template<bool Fields = true, bool Geometry = true, VolumeEquation EquationT, typename SchemaT> void \fBapply_volume_direction\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, const std::array< const \fB::mfem::Vector\fP *, \fBEquationPlan\fP< EquationT >::column_count > &directions, const \fB::mfem::Vector\fP &displacement_direction, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Apply only the requested directions and assemble their supported residual contribution\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> void \fBapply_volume_displacements\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, std::span< const \fB::mfem::Vector\fP *const > displacement_directions, std::span<\fB::mfem::Vector\fP *const > results)"
|
|
.br
|
|
.RI "apply_volume_direction<false, true> for several displacement directions in one traversal\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename CoefficientsT> void \fBapply_jacobian\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, const CoefficientsT &direction, const \fB::mfem::Vector\fP &displacement_direction, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Apply a direction whose terms explicitly name the accepted coefficient bindings\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> void \fBapply_jacobian\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, const \fB::mfem::Vector\fP &direction, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Unpack unique coefficient terms and displacement, then use the same numerical action\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT> void \fBapply_jacobian_transpose\fP (const \fBVolumeData\fP< EquationT, SchemaT > &data, const \fB::mfem::Vector\fP &residual_dual, \fBWorkspace\fP &workspace, \fB::mfem::Vector\fP &result)"
|
|
.br
|
|
.RI "Assemble the full coordinate transpose in the same packed order as the forward action\&. "
|
|
.ti -1c
|
|
.RI "template<std::size_t Contribution, typename OperandT, VolumeEquation EquationT, typename SchemaT, typename Scope = void> auto \fBmake_operand_computations\fP (const std::shared_ptr< \fBVolumeScratch\fP > &scratch)"
|
|
.br
|
|
.RI "Declare one coefficient contraction, followed by a physical mapping when the space requires it\&. "
|
|
.ti -1c
|
|
.RI "template<std::size_t Index, typename Scope, VolumeEquation EquationT, typename SchemaT, typename ContributionT, typename\&.\&.\&. Operands> auto \fBmake_contribution_computations\fP (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > &configuration, const std::shared_ptr< \fBVolumeScratch\fP > &scratch, \fBContributionBinding\fP< ContributionT > contribution, \fButils::types::TypeList\fP< Operands\&.\&.\&. >)"
|
|
.br
|
|
.RI "Build one contribution's branch in the same order as its numerical description\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT, std::size_t\&.\&.\&. Indices> auto \fBconnect_volume_contributions\fP (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > &configuration, std::index_sequence< Indices\&.\&.\&. >)"
|
|
.br
|
|
.RI "Expose contribution computations so deformation and equations can share one dependency graph\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, std::size_t Index, typename Scope = void, typename CacheT> void \fBreport_contribution_preparation\fP (const CacheT &cache, \fBNumericalWork\fP &report)"
|
|
.br
|
|
.RI "Convert the dependency engine's node statuses to numerical work counts for one contribution\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT> auto \fBmake_volume_equation_computations\fP (std::shared_ptr< const EquationT > equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, \fBVolumeOptions\fP options={})"
|
|
.br
|
|
.RI "Declare reusable volume computations without selecting their source of displacement\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT> auto \fBmake_volume_equation_computations\fP (EquationT equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, \fBVolumeOptions\fP options={})"
|
|
.br
|
|
.RI "Own standalone equations while allowing complete models to share their existing immutable members\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT, typename InputsT> auto \fBmake_volume_equation_cache\fP (EquationT equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const InputsT &inputs, \fBVolumeOptions\fP options={})"
|
|
.br
|
|
.RI "Construct a standalone cache from the same computations used by a coupled deformation graph\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, typename CacheT, typename DiscretizationT, typename CoefficientsT> std::expected< void, \fBPreparationRejection\fP > \fBtry_prepare_volume\fP (CacheT &cache, const DiscretizationT &discretization, const CoefficientsT &term_coefficients, const \fB::mfem::Vector\fP &displacement_coefficients, \fBPreparationMode\fP mode=PreparationMode::reuse_unchanged)"
|
|
.br
|
|
.RI "Validate current inputs and atomically publish a complete volume linearization\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, typename CacheT, typename DiscretizationT, typename CoefficientsT> void \fBprepare_volume\fP (CacheT &cache, const DiscretizationT &discretization, const CoefficientsT &term_coefficients, const \fB::mfem::Vector\fP &displacement_coefficients, \fBPreparationMode\fP mode=PreparationMode::reuse_unchanged)"
|
|
.br
|
|
.RI "Throw a caller-visible numerical error when a complete preparation cannot be accepted\&. "
|
|
.ti -1c
|
|
.RI "template<typename Scope = void, typename CacheT> \fBNumericalWork\fP \fBvolume_work_report\fP (const CacheT &cache)"
|
|
.br
|
|
.RI "Derive work counts from accepted node statuses; no second report lifecycle is stored\&. "
|
|
.ti -1c
|
|
.RI "template<typename TestT, typename SchemaT> \fBVolumeDiscretization\fP (const \fBdiscretization::backend::mfem::TermBinding\fP< TestT, SchemaT > &, const \fBdiscretization::backend::mfem::TermBinding\fP< \fBdiscretization::blocks::displacement::vector\fP, SchemaT > &, const ::mfem::GridFunction &, const \fBmapping::DomainMapper\fP &) \-> VolumeDiscretization< TestT, SchemaT >"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> std::shared_ptr< const ::mfem::SparseMatrix > \fBassemble_volume_field\fP (const \fBVolumeData\fP< Equation, \fBSchema\fP > &data)"
|
|
.br
|
|
.RI "Assemble a selected field block from accepted weighted derivatives, never by probing the whole system\&. "
|
|
.ti -1c
|
|
.RI "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> std::vector< double > \fBvolume_field_diagonal\fP (const \fBVolumeData\fP< Equation, \fBSchema\fP > &data)"
|
|
.br
|
|
.RI "Extract exact physical diagonals, retaining constraint cross terms when hanging nodes are present\&. "
|
|
.ti -1c
|
|
.RI "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> \fBLinearizedBlock\fP \fBvolume_field_block\fP (std::shared_ptr< const \fBVolumeData\fP< Equation, \fBSchema\fP > > data)"
|
|
.br
|
|
.RI "Expose efficient physical block operations from an owning accepted dependency result\&. "
|
|
.ti -1c
|
|
.RI "template<typename TestT, typename SchemaT> void \fBvalidate_volume_discretization\fP (const \fBVolumeDiscretization\fP< TestT, SchemaT > &discretization)"
|
|
.br
|
|
.RI "Check borrowed mesh objects before sampling or applying accepted results\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto \fBmake_volume_binding_input\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. >)"
|
|
.br
|
|
.RI "Validate one equation's bindings without constructing duplicate coefficient resources\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto \fBmake_volume_binding_input\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients)"
|
|
.br
|
|
.RI "Share equation metadata with a model's common physical coefficient context\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. > columns)"
|
|
.br
|
|
.RI "Supply precisely the consumed terms for a standalone equation\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients)"
|
|
.br
|
|
.RI "Bind equation and reference inputs when displacement will be produced inside the dependency graph\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients, const \fB::mfem::Vector\fP &displacement_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. > columns)"
|
|
.br
|
|
.RI "Append a checked external displacement while preserving each original resource's tracking policy\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &discretization, const CoefficientsT &term_coefficients, const \fB::mfem::Vector\fP &displacement_coefficients)"
|
|
.br
|
|
.RI "Build a checked source context without retaining the coefficient vectors\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> void \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &, const CoefficientsT &, \fB::mfem::Vector\fP &&)=delete"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> void \fBmake_volume_inputs\fP (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > &, const CoefficientsT &, const \fB::mfem::Vector\fP &&)=delete"
|
|
.br
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename ContributionT> std::expected< \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > >, \fBPreparationRejection\fP > \fBsample_contribution_basis\fP (const \fBVolumeConfiguration\fP< EquationT, SchemaT > &configuration, const \fBContributionBinding\fP< ContributionT > &contribution, const \fBBasisBindings\fP< \fBEquationPlan\fP< EquationT >::column_count > &bindings, \fBTensorBasisCache\fP &cache)"
|
|
.br
|
|
.RI "Sample the reference discretization once for each supported element of this contribution\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename OperandT, typename BindingT> \fBOperandSamples\fP \fBsample_contribution_operand\fP (const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > &basis, const \fBCoefficientView\fP< BindingT > &input, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Only this operand's coefficients and reference basis determine its reference samples\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename ContributionT> std::expected< \fBElementBatch\fP< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > >, \fBPreparationRejection\fP > \fBmap_contribution_geometry\fP (const \fBVolumeConfiguration\fP< EquationT, SchemaT > &configuration, const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > &basis, const \fBCoefficientView\fP< typename \fBVolumeConfiguration\fP< EquationT, SchemaT >::DisplacementBinding > &displacement, const \fBMappingCoefficients\fP &compactification, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Freeze mapping data and mapped bases independently of the equation's coefficient inputs\&. "
|
|
.ti -1c
|
|
.RI "template<typename OperandT, std::size_t OperandCount> \fBOperandSamples\fP \fBmap_contribution_operand\fP (const \fBOperandSamples\fP &samples, const \fBElementBatch\fP< \fBElementGeometry\fP< OperandCount > > &geometry, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Map only operands whose physical representation depends on deformation\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation Equation, typename \fBSchema\fP, typename Contribution> std::expected< \fBElementBatch\fP<::mfem::DenseMatrix >, \fBPreparationRejection\fP > \fBdifferentiate_contribution_geometry\fP (const \fBVolumeConfiguration\fP< Equation, \fBSchema\fP > &configuration, const \fBContributionData\fP< \fBEquationPlan\fP< Equation >::operand_count > &contribution, \fBWorkspace\fP &workspace)"
|
|
.br
|
|
.RI "Compute local displacement derivatives as an immutable graph result for this contribution\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename ContributionT, typename\&.\&.\&. Operands> std::expected< \fBContributionData\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > \fBevaluate_contribution_equation\fP (const \fBContributionBinding\fP< ContributionT > &contribution, const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > &basis, const \fBElementBatch\fP< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > > &geometry, \fBWorkspace\fP &workspace, const \fBSamplesFor\fP< Operands > &\&.\&.\&. samples)"
|
|
.br
|
|
.RI "Evaluate one equation contribution; its basis, mapping and individual operand samples are already prepared\&. "
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, typename SchemaT, typename\&.\&.\&. Contributions> std::expected< \fBVolumeData\fP< EquationT, SchemaT >, \fBPreparationRejection\fP > \fBcollect_volume_results\fP (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > &configuration, const \fBBasisBindings\fP< \fBEquationPlan\fP< EquationT >::column_count > &bindings, \fBWorkspace\fP &workspace, const Contributions &\&.\&.\&. contributions)"
|
|
.br
|
|
.RI "Collect the results of all contributions into a single \fBVolumeData\fP\&. This contains the residuals due to each contribution for all degrees of freedom as well as data needed for subsequent jacobian calculations\&. "
|
|
.in -1c
|
|
.SS "Variables"
|
|
|
|
.in +1c
|
|
.ti -1c
|
|
.RI "template<VolumeEquation EquationT, EvaluableOperand OperandT, typename BindingT> constexpr std::size_t \fBindex\fP = \fBequations::OperandValues\fP<typename Plan::Operands>::template index<OperandT>()"
|
|
.br
|
|
.RI "Contract one operand's fixed-mesh basis with its current coefficients\&. "
|
|
.ti -1c
|
|
.RI "\fB::mfem::Vector\fP \fBvalues\fP"
|
|
.br
|
|
.in -1c
|
|
.SH "Typedef Documentation"
|
|
.PP
|
|
.SS "using \fBserif::operators::backend::mfem::Density\fP = \fBdiscretization::forms::Operand\fP<\fBdiscretization::blocks::density::mass\fP>"
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::DensityBinding\fP = \fBdiscretization::backend::mfem::TermBinding\fP<\fBClosure::Test\fP, \fBSchema\fP>"
|
|
|
|
.SS "template<typename ElementT> using \fBserif::operators::backend::mfem::ElementBatch\fP = std::vector<std::shared_ptr<const ElementT>>"
|
|
|
|
.PP
|
|
A stage owns immutable element results, shared with downstream stages and accepted linearizations\&.
|
|
.SS "using \fBserif::operators::backend::mfem::MatrixAction\fP = std::function<void(const \fB::mfem::Vector\fP&, \fB::mfem::Vector\fP&)>"
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::MatrixArrayAction\fP = std::function<void(std::span<const \fB::mfem::Vector\fP* const>, std::span<\fB::mfem::Vector\fP* const>)>"
|
|
|
|
.PP
|
|
Apply the forward action to several directions at once (zeroed outputs, as \fBMatrixAction\fP receives)\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
Each output must equal what \fBMatrixAction\fP produces for its input; batching only shares traversals\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::MeshAndCoefficientBindings\fP = \fBvolume_keys::Scoped\fP<void>::Bindings"
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::PreparationMode\fP = \fButils::dependencies::PreparationMode\fP"
|
|
|
|
.SS "template<typename OperandT> using \fBserif::operators::backend::mfem::SamplesFor\fP = \fBOperandSamples\fP"
|
|
|
|
.PP
|
|
Associate an operand type pack with equally ordered sample arguments\&.
|
|
.SS "using \fBserif::operators::backend::mfem::Schema\fP = \fBdiscretization::domain::schema::CoreEnvelopeVacuumDomainSchema\fP"
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::Vector\fP = ::mfem::Vector"
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::VolumeCache\fP"
|
|
\fBInitial value:\fP
|
|
.nf
|
|
decltype(make_volume_equation_cache(
|
|
std::declval<Closure>(), std::declval<VolumeMesh>(), std::declval<const VolumeInputs&>()
|
|
))
|
|
.PP
|
|
.fi
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::VolumeCoefficients\fP"
|
|
\fBInitial value:\fP
|
|
.nf
|
|
decltype(make_term_coefficients(
|
|
bind(std::declval<const DensityBinding&>(), std::declval<const Vector&>())
|
|
))
|
|
.PP
|
|
.fi
|
|
|
|
.SS "template<typename CacheT, typename Scope = void> using \fBserif::operators::backend::mfem::VolumeEquationOf\fP = typename std::remove_cvref_t<decltype(std::declval<const CacheT&>()\&.template get<typename \fBvolume_keys::Scoped\fP<Scope>::Linearization>())>::Equation"
|
|
|
|
.PP
|
|
Recover the equation type from a cache's accepted result type, without accessing a result\&.
|
|
.SS "using \fBserif::operators::backend::mfem::VolumeInputs\fP"
|
|
\fBInitial value:\fP
|
|
.nf
|
|
decltype(make_volume_inputs<Closure>(
|
|
std::declval<const VolumeMesh&>(), std::declval<const VolumeCoefficients&>(), std::declval<const Vector&>()
|
|
))
|
|
.PP
|
|
.fi
|
|
|
|
.SS "using \fBserif::operators::backend::mfem::VolumeMesh\fP = \fBVolumeDiscretization\fP<\fBClosure::Test\fP, \fBSchema\fP>"
|
|
|
|
.SS "template<std::size_t Contribution, typename OperandT, typename Scope = void> using \fBserif::operators::backend::mfem::VolumeOperandResult\fP"
|
|
\fBInitial value:\fP
|
|
.nf
|
|
|
|
std::conditional_t<OperandEvaluator<OperandT>::geometry_dependent, typename volume_keys::Scoped<Scope>::template PhysicalValues<Contribution, OperandT>,
|
|
typename volume_keys::Scoped<Scope>::template ReferenceValues<Contribution, OperandT>>
|
|
.PP
|
|
.fi
|
|
|
|
.PP
|
|
Values need a mapping node only when the operand's physical representation depends on geometry\&.
|
|
.SH "Enumeration Type Documentation"
|
|
.PP
|
|
.SS "enum class \fBserif::discretization::backend::mfem::ContractionMode\fP\fR [strong]\fP"
|
|
|
|
.PP
|
|
Options enum to control how the tensor contractions are performed\&.
|
|
.SS "enum class \fBserif::discretization::backend::mfem::ContractionMode\fP\fR [strong]\fP"
|
|
|
|
.PP
|
|
Options enum to control how the tensor contractions are performed\&.
|
|
.SS "enum class \fBserif::operators::backend::mfem::PreparationRejectionReason\fP\fR [strong]\fP"
|
|
|
|
.PP
|
|
\fBEnumerator\fP
|
|
.in +1c
|
|
.TP
|
|
\f(BIMAPPING \fP
|
|
.TP
|
|
\f(BIEQUATION \fP
|
|
.TP
|
|
\f(BINON_FINITE \fP
|
|
.SS "enum class \fBserif::discretization::backend::mfem::ReferenceOperation\fP\fR [strong]\fP"
|
|
|
|
.PP
|
|
Options enum to control what is actually evaluated at the reference points\&.
|
|
.SH "Function Documentation"
|
|
.PP
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::apply_jacobian (const \fBVolumeData\fP< EquationT, SchemaT > & data, const \fB::mfem::Vector\fP & direction, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Unpack unique coefficient terms and displacement, then use the same numerical action\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename CoefficientsT> void serif::operators::backend::mfem::apply_jacobian (const \fBVolumeData\fP< EquationT, SchemaT > & data, const CoefficientsT & direction, const \fB::mfem::Vector\fP & displacement_direction, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Apply a direction whose terms explicitly name the accepted coefficient bindings\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::apply_jacobian_transpose (const \fBVolumeData\fP< EquationT, SchemaT > & data, const \fB::mfem::Vector\fP & residual_dual, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Assemble the full coordinate transpose in the same packed order as the forward action\&.
|
|
.SS "void serif::operators::backend::mfem::apply_many (const ::mfem::Operator & action, std::span< const \fB::mfem::Vector\fP *const > inputs, std::span<\fB::mfem::Vector\fP *const > outputs)"
|
|
|
|
.PP
|
|
Apply an operator to several directions; ArrayMult for SERiF actions, otherwise one Mult per direction\&.
|
|
.SS "template<bool Fields = true, bool Geometry = true, VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::apply_volume_direction (const \fBVolumeData\fP< EquationT, SchemaT > & data, const std::array< const \fB::mfem::Vector\fP *, \fBEquationPlan\fP< EquationT >::column_count > & directions, const \fB::mfem::Vector\fP & displacement_direction, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Apply only the requested directions and assemble their supported residual contribution\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::apply_volume_displacements (const \fBVolumeData\fP< EquationT, SchemaT > & data, std::span< const \fB::mfem::Vector\fP *const > displacement_directions, std::span<\fB::mfem::Vector\fP *const > results)"
|
|
|
|
.PP
|
|
apply_volume_direction<false, true> for several displacement directions in one traversal\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
Every (direction, element) action runs concurrently with worker-owned scratch, then each direction adds its element results in the original element order, so each result equals the single-direction call\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> std::shared_ptr< const ::mfem::SparseMatrix > serif::operators::backend::mfem::assemble_volume_field (const \fBVolumeData\fP< Equation, \fBSchema\fP > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Assemble a selected field block from accepted weighted derivatives, never by probing the whole system\&.
|
|
.SS "template<typename BindingT> void serif::operators::backend::mfem::bind (const BindingT && , const \fB::mfem::Vector\fP & )\fR [delete]\fP"
|
|
|
|
.SS "template<typename BindingT> void serif::operators::backend::mfem::bind (const BindingT & , \fB::mfem::Vector\fP && )\fR [delete]\fP"
|
|
|
|
.SS "template<typename BindingT> void serif::operators::backend::mfem::bind (const BindingT & , const \fB::mfem::Vector\fP && )\fR [delete]\fP"
|
|
|
|
.SS "template<typename BindingT> \fBCoefficientView\fP< BindingT > serif::operators::backend::mfem::bind (const BindingT & binding, const \fB::mfem::Vector\fP & values)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Borrow a term binding and its coefficients without extending their lifetimes\&.
|
|
.SS "std::shared_ptr< const::mfem::SparseMatrix > serif::operators::backend::mfem::checked_assembly (const \fBLinearizedBlock\fP & block)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Assemble a non-null finalized sparse matrix whose dimensions match its declared physical action\&.
|
|
.SS "std::vector< double > serif::operators::backend::mfem::checked_diagonal (const \fBLinearizedBlock\fP & block)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Extract a diagonal and reject a callback that violates its declared physical block dimensions\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename\&.\&.\&. Contributions> std::expected< \fBVolumeData\fP< EquationT, SchemaT >, \fBPreparationRejection\fP > serif::operators::backend::mfem::collect_volume_results (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > & configuration, const \fBBasisBindings\fP< \fBEquationPlan\fP< EquationT >::column_count > & bindings, \fBWorkspace\fP & workspace, const Contributions &\&.\&.\&. contributions)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Collect the results of all contributions into a single \fBVolumeData\fP\&. This contains the residuals due to each contribution for all degrees of freedom as well as data needed for subsequent jacobian calculations\&.
|
|
.PP
|
|
\fBTemplate Parameters\fP
|
|
.RS 4
|
|
\fIEquationT\fP The equation type which is being solved, this is used to determine the test and operand types\&.
|
|
.br
|
|
\fISchemaT\fP The schema type which is being solved, this is used to constrain the support of the contributions and define which material and boundary attributes belong to what dofs
|
|
.br
|
|
\fIContributions\fP The contributions which are being evaluated, these are the terms in the equation which are being integrated over the volume
|
|
.RE
|
|
.PP
|
|
\fBParameters\fP
|
|
.RS 4
|
|
\fIconfiguration\fP The configuration of the volume problem, including the equation and discretization\&.
|
|
.br
|
|
\fIbindings\fP The basis bindings for the volume problem, including the residual and displacement bindings
|
|
.br
|
|
\fIworkspace\fP The workspace for the volume problem, including the full result vector and element
|
|
.br
|
|
\fIcontributions\fP The contributions to the volume problem, including their basis, geometry, and operand samples\&.
|
|
.RE
|
|
.PP
|
|
\fBReturns\fP
|
|
.RS 4
|
|
A \fBVolumeData\fP object containing the residuals due to each contribution for all degrees of freedom as well as data needed for subsequent jacobian calculations\&.
|
|
.RE
|
|
.PP
|
|
\fBCompiler Errors:\fP
|
|
.RS 4
|
|
|
|
.RE
|
|
.PP
|
|
.IP "\(bu" 2
|
|
If the a contribution defines a residual_offset but that residual offset is not addable to a double producing a double\&.
|
|
.PP
|
|
|
|
.PP
|
|
\fBDetailed Explanation\fP
|
|
.RS 4
|
|
This is a really important function on the backend to lets take some time to walk through it\&. We take in some configuration data (including things like what equation we are solving and what discretization we are using, the basis binding which contains mappings from full dof space to supported dof space, a runtime workspace, and a variable number of contributions\&.
|
|
.RE
|
|
.PP
|
|
After some setup we initialize the \fBVolumeData\fP object which will be what we eventually return\&. The first part is then to loop over all contributions and for each contribution accumulate its residual_offset\&. See \fBAngularMomentumConstraint\fP for more detail; however, the gist is that this is some constant term which should be removed from the final integrated quantity to evaluate the residual (think the integrated angular momentum - the target angular momentum for the residual)\&.
|
|
|
|
.PP
|
|
We first fold over all contributions and accumulate their residuals and following that there is then some basic validation that the total residual offset is finite\&.
|
|
|
|
.PP
|
|
Next we extract the "residual bindings" from the discretization provided by the configuration\&. The residual bindings is a, after a few inheritances, DofMap\&. This means it fundamentally represents some term and how that term is supported on the mesh\&. So when we ask for say the size of the residual binding what that is saying is "how many dofs is this residual defined for"\&. We make the full result a vector the size of the number of dofs the residual is defined for\&.
|
|
|
|
.PP
|
|
We use the CompensatedSum class to help avoid round off and cancellation errors\&.
|
|
|
|
.PP
|
|
We then go through and for each contribution to each element we evaluate the residual from that contribution\&. The evaluate_residual function is the primary function where we actually integrate an equations contributions over a volume and we include this in the global residual sum\&. We fold over and call this function for every contribution and for every element\&. Thereby getting the total residual for the entire volume due to all contributions\&.
|
|
|
|
.PP
|
|
What we end up with is this global_sum\&. We then need to apply one more modification to it, if we are working with some global scalar (e\&.g\&. fixed angular momentum) then we add the residual offset (note that this will often be a negative value, AngularMomentumConstraint for example returns -angular momentum target)\&.
|
|
|
|
.PP
|
|
Then, regardless of if we are working with a global scalar or not we gather the full result into the residual vector\&. Gathering here means that we select all the residual values on supported dofs and distribute them into the correct indices of the full space residual vector\&. Dofs which are not supported by the residual binding will be set to zero\&.
|
|
|
|
.PP
|
|
\fBTL:DR\fP
|
|
.RS 4
|
|
Use this function to evaluate the residual of a volume problem, likely you never need to think about the implementation details\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<std::size_t Count> std::array< \fBdiscretization::backend::mfem::DofMap::Elements\fP, Count > serif::operators::backend::mfem::column_elements (const std::array< const \fBdiscretization::backend::mfem::DofMap\fP *, Count > & columns)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Validate coefficient bindings once before a complete element traversal\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::compose_blocks (\fBLinearizedBlock\fP left, \fBLinearizedBlock\fP right)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Compose linearized blocks in their written mathematical order\&.
|
|
.SS "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT, std::size_t\&.\&.\&. Indices> auto serif::operators::backend::mfem::connect_volume_contributions (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > & configuration, std::index_sequence< Indices\&.\&.\&. > )\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Expose contribution computations so deformation and equations can share one dependency graph\&.
|
|
.SS "template<VolumeEquation Equation, typename \fBSchema\fP, typename Contribution> std::expected< \fBElementBatch\fP<::mfem::DenseMatrix >, \fBPreparationRejection\fP > serif::operators::backend::mfem::differentiate_contribution_geometry (const \fBVolumeConfiguration\fP< Equation, \fBSchema\fP > & configuration, const \fBContributionData\fP< \fBEquationPlan\fP< Equation >::operand_count > & contribution, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Compute local displacement derivatives as an immutable graph result for this contribution\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> \fBequations::EquationPoint\fP< typename ContributionT::Operands > serif::operators::backend::mfem::element_equation_point (const std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > & physical_values, const \fBmapping::MappingPointContext\fP & context, int point)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Pack the physical samples requested by this contribution at one quadrature point\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> void serif::operators::backend::mfem::element_geometry_actions (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > & data, const ::mfem::DenseMatrix & geometry_derivatives, const \fBdiscretization::backend::mfem::DofMap::Elements\fP & displacement_binding, std::span< const \fB::mfem::Vector\fP *const > displacement_directions, \fBWorkspace\fP & workspace, std::span<\fB::mfem::Vector\fP *const > results)"
|
|
|
|
.PP
|
|
element_jacobian_action<false, true> for several displacement directions of one element\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
The displacement samples of all directions come from one lane-batched basis evaluation (each lane equals the single evaluation); every direction is then finished exactly as element_jacobian_action finishes it\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<VolumeEquation Equation, typename Contribution> std::expected<::mfem::DenseMatrix, \fBPreparationRejection\fP > serif::operators::backend::mfem::element_geometry_derivatives (const \fBElementData\fP< \fBEquationPlan\fP< Equation >::operand_count > & data, const \fBdiscretization::backend::mfem::DofMap\fP & displacement_binding, const ::mfem::FiniteElementSpace & compactification_space, const \fBmapping::DomainMapper\fP & mapper, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Differentiate one weighted integrand with respect to local displacement values and gradients\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
The graph owns this matrix\&. Its twelve columns are u_c and partial_{xi_k} u_c, ordered as the displacement basis samples\&. Rows are quadrature points times fixed-mesh test components\&. This includes the variation of the test map: subsequent forward and transpose actions therefore use the same fixed reference basis and never reevaluate the physical mapping\&. The twelve directions are exact local derivatives, independent of finite-element order; they are neither finite differences nor probes of the global coefficient vector\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT, bool Fields = true, bool Geometry = true> void serif::operators::backend::mfem::element_jacobian_action (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > & data, const ::mfem::DenseMatrix & geometry_derivatives, const std::array< \fBdiscretization::backend::mfem::DofMap::Elements\fP, \fBEquationPlan\fP< EquationT >::column_count > & columns, const std::array< const \fB::mfem::Vector\fP *, \fBEquationPlan\fP< EquationT >::column_count > & directions, const \fBdiscretization::backend::mfem::DofMap::Elements\fP & displacement_binding, const \fB::mfem::Vector\fP & displacement_direction, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Apply the accepted field derivatives and local displacement derivatives\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
Geometry derivatives are graph results, expressed against the fixed-mesh test basis\&. The two compile-time switches exclude structurally absent directions without sampling zero fields\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> void serif::operators::backend::mfem::element_jacobian_transpose (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > & data, const ::mfem::DenseMatrix & geometry_derivatives, const \fBdiscretization::backend::mfem::DofMap::Elements\fP & row, const \fB::mfem::Vector\fP & residual_dual, \fBWorkspace\fP & workspace, std::array<\fB::mfem::Vector\fP, \fBEquationPlan\fP< EquationT >::column_count > & column_duals, \fB::mfem::Vector\fP & displacement_dual)"
|
|
|
|
.PP
|
|
Transpose the same accepted field and geometry contractions used by the forward action\&.
|
|
.SS "template<typename ContributionT, std::size_t Count> void serif::operators::backend::mfem::element_residual (const \fBElementData\fP< Count > & data, \fB::mfem::Vector\fP & result, \fBBasisWorkspace\fP & workspace)"
|
|
|
|
.PP
|
|
Integrate the cached scalar/vector physics against its actual test operation\&.
|
|
.SS "elements serif::operators::backend::mfem::element_values (basis\&. element, input\&. values, workspace\&. element_values)"
|
|
|
|
.SS "template<VolumeEquation RowEquationT, typename ContributionT> const ::mfem::IntegrationRule & serif::operators::backend::mfem::equation_rule (const ContributionT & equation, const \fBdiscretization::quadrature::Policy\fP & policy, ::mfem::ElementTransformation & transformation, const ::mfem::FiniteElement & displacement_element, \fBdiscretization::quadrature::MappingKind\fP mapping_kind = \fR\fBdiscretization::quadrature::MappingKind::general\fP\fP, int reconstruction_order = \fR0\fP)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Resolve one rule covering all operand forms and the geometry weight\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT, typename\&.\&.\&. Operands> std::expected< \fBContributionData\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > serif::operators::backend::mfem::evaluate_contribution_equation (const \fBContributionBinding\fP< ContributionT > & contribution, const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > & basis, const \fBElementBatch\fP< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > > & geometry, \fBWorkspace\fP & workspace, const \fBSamplesFor\fP< Operands > &\&.\&.\&. samples)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Evaluate one equation contribution; its basis, mapping and individual operand samples are already prepared\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > serif::operators::backend::mfem::evaluate_element_equation (const ContributionT & equation, double coefficient, std::shared_ptr< const \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > basis, std::shared_ptr< const \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > > geometry, std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > reference_values, const std::array< std::shared_ptr< const \fB::mfem::Vector\fP >, \fBEquationPlan\fP< EquationT >::operand_count > & physical_values, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Evaluate and weight the equation while retaining its immutable preparation inputs\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT, bool Fields, bool Geometry> void serif::operators::backend::mfem::finish_element_action (const \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > & data, const ::mfem::DenseMatrix & geometry_derivatives, \fBWorkspace\fP & workspace, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Finish an element action from its field part (workspace\&.quadrature_values) and, with Geometry, the displacement samples (workspace\&.displacement_samples): contract the geometry derivatives and integrate\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename VisitT> void serif::operators::backend::mfem::for_each_volume_element (const \fBVolumeData\fP< EquationT, SchemaT > & data, VisitT && visit)"
|
|
|
|
.PP
|
|
Visit each contribution's own batch in equation order, without scanning other contributions\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename VisitT> void serif::operators::backend::mfem::for_each_volume_linearization (const \fBVolumeData\fP< EquationT, SchemaT > & data, VisitT && visit)"
|
|
|
|
.PP
|
|
Visit equation data together with its graph-owned local geometry derivative matrix\&.
|
|
.SS "template<VolumeEquation Equation, typename Contribution> auto serif::operators::backend::mfem::geometry_integrand_variation (const \fBElementData\fP< \fBEquationPlan\fP< Equation >::operand_count > & data, int point, const \fBmapping::VolumeMappingContext\fP & context, const \fBmapping::VolumeMappingVariation\fP & variation)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Differentiate the weighted physics through position, operand mappings and the volume measure\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> int serif::operators::backend::mfem::integration_order (const \fBVolumeData\fP< EquationT, SchemaT > & data, int element)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Return the largest contribution quadrature order on a supported mesh element\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::linearized_action (int rows, int columns, \fBMatrixAction\fP action, \fBMatrixAction\fP transpose)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Wrap owned callbacks with checked dimensions, finite results, and overlap-safe application\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::linearized_action (int rows, int columns, \fBMatrixAction\fP action, \fBMatrixAction\fP transpose, \fBMatrixArrayAction\fP batch)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
As above, with a batched forward action used by the operator's ArrayMult\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::linearized_block (std::shared_ptr< const ::mfem::DenseMatrix > matrix)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Retain a small assembled physical block, such as a generated scalar constraint\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::linearized_block (std::shared_ptr< const ::mfem::SparseMatrix > matrix)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Retain an already assembled physical block without copying its matrix\&.
|
|
.SS "template<std::size_t Index, typename Scope, VolumeEquation EquationT, typename SchemaT, typename ContributionT, typename\&.\&.\&. Operands> auto serif::operators::backend::mfem::make_contribution_computations (const std::shared_ptr< const \fBVolumeConfiguration\fP< EquationT, SchemaT > > & configuration, const std::shared_ptr< \fBVolumeScratch\fP > & scratch, \fBContributionBinding\fP< ContributionT > contribution, \fButils::types::TypeList\fP< Operands\&.\&.\&. > )\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Build one contribution's branch in the same order as its numerical description\&.
|
|
.SS "template<std::size_t Contribution, typename OperandT, VolumeEquation EquationT, typename SchemaT, typename Scope = void> auto serif::operators::backend::mfem::make_operand_computations (const std::shared_ptr< \fBVolumeScratch\fP > & scratch)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Declare one coefficient contraction, followed by a physical mapping when the space requires it\&.
|
|
.SS "template<typename\&.\&.\&. BindingTs> auto serif::operators::backend::mfem::make_term_coefficients (BindingTs\&.\&.\&. bindings)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Associate each physical term with its bound coefficients in an ordinary dependency context\&.
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto serif::operators::backend::mfem::make_volume_binding_input (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Share equation metadata with a model's common physical coefficient context\&.
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto serif::operators::backend::mfem::make_volume_binding_input (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. > )\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Validate one equation's bindings without constructing duplicate coefficient resources\&.
|
|
.SS "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT, typename InputsT> auto serif::operators::backend::mfem::make_volume_equation_cache (EquationT equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const InputsT & inputs, \fBVolumeOptions\fP options = \fR{}\fP)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Construct a standalone cache from the same computations used by a coupled deformation graph\&.
|
|
.SS "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT> auto serif::operators::backend::mfem::make_volume_equation_computations (EquationT equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, \fBVolumeOptions\fP options = \fR{}\fP)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Own standalone equations while allowing complete models to share their existing immutable members\&.
|
|
.SS "template<typename Scope = void, VolumeEquation EquationT, typename SchemaT> auto serif::operators::backend::mfem::make_volume_equation_computations (std::shared_ptr< const EquationT > equation, const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, \fBVolumeOptions\fP options = \fR{}\fP)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Declare reusable volume computations without selecting their source of displacement\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
This allocates scratch and owns the equation configuration; numerical work begins at try_prepare\&. Borrowed discretization objects must outlive the computations and their accepted results\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> void serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & , const CoefficientsT & , \fB::mfem::Vector\fP && )\fR [delete]\fP"
|
|
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> void serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & , const CoefficientsT & , const \fB::mfem::Vector\fP && )\fR [delete]\fP"
|
|
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Bind equation and reference inputs when displacement will be produced inside the dependency graph\&.
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT> auto serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients, const \fB::mfem::Vector\fP & displacement_coefficients)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Build a checked source context without retaining the coefficient vectors\&.
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients, const \fB::mfem::Vector\fP & displacement_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. > columns)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Append a checked external displacement while preserving each original resource's tracking policy\&.
|
|
.SS "template<VolumeEquation EquationT, typename Scope = void, typename SchemaT, typename CoefficientsT, typename\&.\&.\&. Columns> auto serif::operators::backend::mfem::make_volume_inputs (const \fBVolumeDiscretization\fP< typename EquationT::Test, SchemaT > & discretization, const CoefficientsT & term_coefficients, \fButils::types::TypeList\fP< Columns\&.\&.\&. > columns)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Supply precisely the consumed terms for a standalone equation\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename ContributionT> std::expected< \fBElementBatch\fP< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count > >, \fBPreparationRejection\fP > serif::operators::backend::mfem::map_contribution_geometry (const \fBVolumeConfiguration\fP< EquationT, SchemaT > & configuration, const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > & basis, const \fBCoefficientView\fP< typename \fBVolumeConfiguration\fP< EquationT, SchemaT >::DisplacementBinding > & displacement, const \fBMappingCoefficients\fP & compactification, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Freeze mapping data and mapped bases independently of the equation's coefficient inputs\&.
|
|
.SS "template<typename OperandT, std::size_t OperandCount> \fBOperandSamples\fP serif::operators::backend::mfem::map_contribution_operand (const \fBOperandSamples\fP & samples, const \fBElementBatch\fP< \fBElementGeometry\fP< OperandCount > > & geometry, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Map only operands whose physical representation depends on deformation\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementGeometry\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > serif::operators::backend::mfem::map_element_geometry (const \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > & basis, const \fBdiscretization::backend::mfem::DofMap\fP & displacement_binding, const \fBdiscretization::backend::mfem::DofMap::Elements\fP & displacement_elements, const \fB::mfem::Vector\fP & displacement, const \fBMappingCoefficients\fP & compactification, const \fBmapping::DomainMapper\fP & mapper, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Freeze displacement and compactification, then map quadrature points and bases to physical space\&.
|
|
.SS "template<EvaluableOperand OperandT, std::size_t Count> \fB::mfem::Vector\fP serif::operators::backend::mfem::map_element_operand (const \fB::mfem::Vector\fP & reference, const \fBElementGeometry\fP< Count > & geometry, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Apply an operand's physical transformation to its cached fixed-mesh samples\&.
|
|
.SS "template<typename Scope = void, typename CacheT, typename DiscretizationT, typename CoefficientsT> void serif::operators::backend::mfem::prepare_volume (CacheT & cache, const DiscretizationT & discretization, const CoefficientsT & term_coefficients, const \fB::mfem::Vector\fP & displacement_coefficients, \fBPreparationMode\fP mode = \fRPreparationMode::reuse_unchanged\fP)"
|
|
|
|
.PP
|
|
Throw a caller-visible numerical error when a complete preparation cannot be accepted\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::replace_block_rows (\fBLinearizedBlock\fP original, std::vector< int > selected_rows, std::shared_ptr< const ::mfem::SparseMatrix > replacement)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Replace selected physical equation rows with an immutable sparse row block in the same unknown coordinates\&.
|
|
.PP
|
|
\fBNote\fP
|
|
.RS 4
|
|
Replacement row i belongs to selected_rows[i]\&. Efficient diagonal and sparse assembly remain available when the original block supplies them; no columns are probed\&. Both matrices must remain immutable after publication\&.
|
|
.RE
|
|
.PP
|
|
|
|
.SS "template<VolumeEquation EquationT, std::size_t Index, typename Scope = void, typename CacheT> void serif::operators::backend::mfem::report_contribution_preparation (const CacheT & cache, \fBNumericalWork\fP & report)"
|
|
|
|
.PP
|
|
Convert the dependency engine's node statuses to numerical work counts for one contribution\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT, typename ContributionT> std::expected< \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > >, \fBPreparationRejection\fP > serif::operators::backend::mfem::sample_contribution_basis (const \fBVolumeConfiguration\fP< EquationT, SchemaT > & configuration, const \fBContributionBinding\fP< ContributionT > & contribution, const \fBBasisBindings\fP< \fBEquationPlan\fP< EquationT >::column_count > & bindings, \fBTensorBasisCache\fP & cache)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Sample the reference discretization once for each supported element of this contribution\&.
|
|
.SS "template<VolumeEquation EquationT, typename OperandT, typename BindingT> \fBOperandSamples\fP serif::operators::backend::mfem::sample_contribution_operand (const \fBElementBatch\fP< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count > > & basis, const \fBCoefficientView\fP< BindingT > & input, \fBWorkspace\fP & workspace)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Only this operand's coefficients and reference basis determine its reference samples\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> std::expected< \fBElementBasis\fP< \fBEquationPlan\fP< EquationT >::operand_count >, \fBPreparationRejection\fP > serif::operators::backend::mfem::sample_element_basis (const ContributionT & equation, int element, const \fBdiscretization::backend::mfem::DofMap\fP & row, const \fBdiscretization::backend::mfem::DofMap\fP & displacement_binding, const std::array< const \fBdiscretization::backend::mfem::DofMap\fP *, \fBEquationPlan\fP< EquationT >::column_count > & columns, const \fBmapping::DomainMapper\fP & mapper, const \fBdiscretization::quadrature::Policy\fP & policy, \fBTensorBasisCache\fP & basis_cache, \fBContractionMode\fP contraction_mode)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Sample the contribution's quadrature rule and bases on the fixed computational mesh\&.
|
|
.SS "template<VolumeEquation EquationT, typename ContributionT> bool serif::operators::backend::mfem::store_element_linearization (const \fBequations::PointLinearization\fP< typename ContributionT::Operands, typename \fBOperandEvaluator\fP< \fBequations::TestOperandOf\fP< ContributionT > >::Value > & physics, int point, double weight, \fBElementData\fP< \fBEquationPlan\fP< EquationT >::operand_count > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Weight a point's residual and derivatives; reject any non-finite stored component\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::sum_blocks (int rows, int columns, std::vector< \fBLinearizedBlock\fP > blocks)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Sum compatible linearized blocks while retaining their native diagonal and sparse assembly operations\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> std::size_t serif::operators::backend::mfem::tensor_element_count (const \fBVolumeData\fP< EquationT, SchemaT > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Count contribution-elements using tensor contractions for any sampled basis\&.
|
|
.SS "\fBLinearizedBlock\fP serif::operators::backend::mfem::transpose_block (\fBLinearizedBlock\fP block)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Transpose a linearized block without discarding efficient assembly and diagonal operations\&.
|
|
.SS "template<typename CacheT, typename PrepareT> std::expected< void, \fBPreparationRejection\fP > serif::operators::backend::mfem::try_prepare_validated (CacheT & cache, PrepareT && prepare)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
A failed validation or calculation must make the previous accepted result inaccessible\&. Make previous results unavailable whenever preparation exits unsuccessfully\&.
|
|
.SS "template<typename Scope = void, typename CacheT, typename DiscretizationT, typename CoefficientsT> std::expected< void, \fBPreparationRejection\fP > serif::operators::backend::mfem::try_prepare_volume (CacheT & cache, const DiscretizationT & discretization, const CoefficientsT & term_coefficients, const \fB::mfem::Vector\fP & displacement_coefficients, \fBPreparationMode\fP mode = \fRPreparationMode::reuse_unchanged\fP)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Validate current inputs and atomically publish a complete volume linearization\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::validate_volume_data (const \fBVolumeData\fP< EquationT, SchemaT > & data)"
|
|
|
|
.PP
|
|
Reject changes to discretization objects borrowed by an accepted linearization\&.
|
|
.SS "template<typename TestT, typename SchemaT> void serif::operators::backend::mfem::validate_volume_discretization (const \fBVolumeDiscretization\fP< TestT, SchemaT > & discretization)"
|
|
|
|
.PP
|
|
Check borrowed mesh objects before sampling or applying accepted results\&.
|
|
.SS "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> \fBLinearizedBlock\fP serif::operators::backend::mfem::volume_field_block (std::shared_ptr< const \fBVolumeData\fP< Equation, \fBSchema\fP > > data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Expose efficient physical block operations from an owning accepted dependency result\&.
|
|
.SS "template<typename Field, VolumeEquation Equation, typename \fBSchema\fP> std::vector< double > serif::operators::backend::mfem::volume_field_diagonal (const \fBVolumeData\fP< Equation, \fBSchema\fP > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Extract exact physical diagonals, retaining constraint cross terms when hanging nodes are present\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> int serif::operators::backend::mfem::volume_height (const \fBVolumeData\fP< EquationT, SchemaT > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Return the supported residual size\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> void serif::operators::backend::mfem::volume_residual (const \fBVolumeData\fP< EquationT, SchemaT > & data, \fB::mfem::Vector\fP & result)"
|
|
|
|
.PP
|
|
Copy the residual already assembled and checked when this result was accepted\&.
|
|
.SS "template<VolumeEquation EquationT, typename SchemaT> int serif::operators::backend::mfem::volume_width (const \fBVolumeData\fP< EquationT, SchemaT > & data)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Packed directions contain unique coefficient terms followed by displacement\&.
|
|
.SS "template<typename Scope = void, typename CacheT> \fBNumericalWork\fP serif::operators::backend::mfem::volume_work_report (const CacheT & cache)\fR [nodiscard]\fP"
|
|
|
|
.PP
|
|
Derive work counts from accepted node statuses; no second report lifecycle is stored\&.
|
|
.SS "template<typename TestT, typename SchemaT> serif::operators::backend::mfem::VolumeDiscretization (const \fBdiscretization::backend::mfem::TermBinding\fP< TestT, SchemaT > & , const \fBdiscretization::backend::mfem::TermBinding\fP< \fBdiscretization::blocks::displacement::vector\fP, SchemaT > & , const ::mfem::GridFunction & , const \fBmapping::DomainMapper\fP & ) \-> VolumeDiscretization< TestT, SchemaT >"
|
|
|
|
.SH "Variable Documentation"
|
|
.PP
|
|
.SS "template<VolumeEquation EquationT, EvaluableOperand OperandT, typename BindingT> std::size_t serif::operators::backend::mfem::index = \fBequations::OperandValues\fP<typename Plan::Operands>::template index<OperandT>()\fR [nodiscard]\fP, \fR [constexpr]\fP"
|
|
|
|
.PP
|
|
Contract one operand's fixed-mesh basis with its current coefficients\&.
|
|
.SS "return serif::operators::backend::mfem::values"
|
|
|
|
.SH "Author"
|
|
.PP
|
|
Generated automatically by Doxygen for SERiF from the source code\&.
|