element_preparation.hpp array cmath expected memory utility serif/backend/mfem/mapping/domain_mapper.hpp serif/backend/mfem/operators/element_data.hpp serif/backend/mfem/operators/operand_evaluation.hpp serif/backend/mfem/operators/quadrature.hpp serif/backend/mfem/operators/rejection.hpp serif/backend/mfem/discretization/term_coefficients.hpp serif/backend/mfem/operators/workspace.hpp serif/backend/mfem/shared/parallel.hpp serif/utils/misc/compensated_sum.hpp src/include/serif/backend/mfem/operators/volume_stages.hpp serif/backend/mfem/discretization/basis_evaluation.hpp serif/backend/mfem/discretization/dof_map.hpp serif/backend/mfem/discretization/quadrature/concepts.hpp serif/backend/mfem/discretization/quadrature/configure.hpp serif/backend/mfem/discretization/quadrature/mfem_resolver.hpp serif/backend/mfem/discretization/quadrature/mfem_static_order.hpp serif/backend/mfem/discretization/quadrature/order.hpp serif/backend/mfem/discretization/reconstruction.hpp serif/backend/mfem/discretization/tensor_basis.hpp serif/backend/mfem/discretization/term_binding.hpp serif/backend/mfem/discretization/term_coefficients.hpp serif/backend/mfem/mapping/compactification/compactification.hpp serif/backend/mfem/mapping/compactification/input_result.hpp serif/backend/mfem/mapping/compactification/kelvin.hpp serif/backend/mfem/mapping/compactification/variation.hpp serif/backend/mfem/mapping/context.hpp serif/backend/mfem/mapping/data.hpp serif/backend/mfem/mapping/domain_mapper.hpp serif/backend/mfem/mapping/status.hpp serif/backend/mfem/mapping/transformations.hpp serif/backend/mfem/mapping/variation.hpp serif/backend/mfem/mapping/volume_cache.hpp serif/backend/mfem/operators/element_data.hpp src/include/serif/backend/mfem/operators/element_preparation.hpp serif/backend/mfem/operators/operand_evaluation.hpp serif/backend/mfem/operators/quadrature.hpp serif/backend/mfem/operators/rejection.hpp serif/backend/mfem/operators/workspace.hpp serif/backend/mfem/shared/parallel.hpp serif/dimensions/dimensions.hpp serif/dimensions/quantities.hpp serif/discretization/blocks/base.hpp serif/discretization/blocks/concepts.hpp serif/discretization/blocks/fields.hpp serif/discretization/blocks/runtime.hpp serif/discretization/blocks/traits.hpp serif/discretization/domain/concepts.hpp serif/discretization/domain/ids/boundary.hpp serif/discretization/domain/ids/concepts.hpp serif/discretization/domain/ids/domain.hpp serif/discretization/domain/ids/lists/concepts.hpp serif/discretization/domain/ids/lists/lists.hpp serif/discretization/domain/ids/lists/traits.hpp serif/discretization/domain/ids/validation/concepts.hpp serif/discretization/domain/ids/validation/unique_ids.hpp serif/discretization/domain/physical_domains.hpp serif/discretization/domain/relation/concepts.hpp serif/discretization/domain/relation/lists/concepts.hpp serif/discretization/domain/relation/lists/relation_list.hpp serif/discretization/domain/relation/lists/traits.hpp serif/discretization/domain/relation/relations.hpp serif/discretization/domain/relation/validation/concepts.hpp serif/discretization/domain/relation/validation/validation.hpp serif/discretization/domain/resolver.hpp serif/discretization/domain/schema/concepts.hpp serif/discretization/domain/schema/domain_schema.hpp serif/discretization/domain/schema/traits.hpp serif/discretization/domain/types.hpp serif/discretization/forms/concept.hpp serif/discretization/forms/form_traits.hpp serif/discretization/forms/forms.hpp serif/discretization/forms/operands.hpp serif/discretization/forms/runtime.hpp serif/discretization/forms/value.hpp serif/discretization/functional_space/space.hpp serif/discretization/quadrature/policy.hpp serif/discretization/quadrature/query.hpp serif/discretization/quadrature/rules.hpp serif/discretization/reconstruction/surface_power.hpp serif/equations/concepts.hpp serif/equations/contributions.hpp serif/equations/point.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/operators/concepts.hpp serif/operators/plan.hpp serif/utils/dependencies/binding.hpp serif/utils/dependencies/dependency_context.hpp serif/utils/dependencies/detail/type_lists.hpp serif/utils/dependencies/key_list.hpp serif/utils/dependencies/key_list_operations.hpp serif/utils/dependencies/resource.hpp serif/utils/dependencies/snapshot.hpp serif/utils/error/codes.hpp serif/utils/error/errors.hpp serif/utils/error/nonfinite.hpp serif/utils/format/strings.hpp serif/utils/misc/compensated_sum.hpp serif/utils/misc/concepts/concat.hpp serif/utils/misc/concepts/exceptions.hpp serif/utils/misc/concepts/numeric.hpp serif/utils/misc/concepts/type_uniqueness.hpp serif/utils/misc/std_helper/cleaning.hpp serif/utils/misc/std_helper/variadic_cleaning.hpp serif/utils/misc/terminal/colors.hpp serif/utils/misc/traits/type_uniqueness.hpp serif/utils/types/strings.hpp serif/utils/types/type_list.hpp serif/utils/user_options/mapping/compactification/kelvin.hpp serif/utils/user_options/mapping/domain_mapper.hpp algorithm array cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional iostream limits magic_enum/magic_enum_all.hpp memory mfem/fem/eltrans.hpp mfem/fem/fe/fe_base.hpp mfem/fem/fe/fe_h1.hpp mfem/fem/fe/fe_l2.hpp mfem/fem/fespace.hpp mfem/fem/geom.hpp mfem/fem/intrules.hpp mfem/fem/pfespace.hpp mfem/linalg/densemat.hpp mfem/linalg/vector.hpp mfem/mesh/mesh.hpp nameof.hpp numeric optional span stdexcept string string_view tuple type_traits unistd.h unordered_map utility vector version src/compile_time_checks/serif/model/scalar_row.cpp src/compile_time_checks/serif/model/state.cpp src/compile_time_checks/serif/operators/computation_owners.cpp src/include/serif/backend/mfem/model/computations/interior.hpp src/include/serif/backend/mfem/model/computations/potential_infinity.hpp src/include/serif/backend/mfem/model/computations/pressure_boundary.hpp src/include/serif/backend/mfem/model/computations/scalar_row.hpp src/include/serif/backend/mfem/model/computations/surface_potential.hpp src/include/serif/backend/mfem/model/equilibrium.hpp src/include/serif/backend/mfem/model/graph.hpp src/include/serif/backend/mfem/operators/element_preparation.hpp src/include/serif/backend/mfem/operators/volume_computations.hpp src/include/serif/backend/mfem/operators/volume_stages.hpp src/include/serif/backend/mfem/solver/admissibility/geometry.hpp src/include/serif/backend/mfem/solver/equilibrium.hpp src/include/serif/backend/mfem/solver/nonlinear/stellar_problem.hpp src/include/serif/solver/continuation/equilibrium.hpp src/include/serif/solver/equilibrium.hpp src/include/serif/solver/solver.hpp serif serif::operators serif::operators::backend serif::operators::backend::mfem #pragmaonce #include<array> #include<cmath> #include<expected> #include<memory> #include<utility> #include"serif/backend/mfem/mapping/domain_mapper.hpp" #include"serif/backend/mfem/operators/element_data.hpp" #include"serif/backend/mfem/operators/operand_evaluation.hpp" #include"serif/backend/mfem/operators/quadrature.hpp" #include"serif/backend/mfem/operators/rejection.hpp" #include"serif/backend/mfem/discretization/term_coefficients.hpp" #include"serif/backend/mfem/operators/workspace.hpp" #include"serif/backend/mfem/shared/parallel.hpp" #include"serif/utils/misc/compensated_sum.hpp" namespaceserif::operators::backend::mfem{ template<VolumeEquationEquationT,typenameContributionT> [[nodiscard]]std::expected<ElementBasis<EquationPlan<EquationT>::operand_count>,PreparationRejection>sample_element_basis( constContributionT&equation, intelement, constdiscretization::backend::mfem::DofMap&row, constdiscretization::backend::mfem::DofMap&displacement_binding, conststd::array<constdiscretization::backend::mfem::DofMap*,EquationPlan<EquationT>::column_count>&columns, constmapping::DomainMapper&mapper, constdiscretization::quadrature::Policy&policy, TensorBasisCache&basis_cache, ContractionModecontraction_mode ){ usingPlan=EquationPlan<EquationT>; usingTest=OperandEvaluator<equations::TestOperandOf<ContributionT>>; auto&transformation=*displacement_binding.space().GetElementTransformation(element); constauto&displacement_element=*displacement_binding.space().GetFE(element); constautomapping_kind=mapper.is_compactified_element(transformation)?discretization::quadrature::MappingKind::kelvin:discretization::quadrature::MappingKind::general; ElementBasis<Plan::operand_count>basis{ .element=element }; intreconstruction_order=0; constautoinclude_reconstruction=[&](constauto&binding){ if(binding.reconstruction_element(element)!=nullptr){ reconstruction_order=std::max(reconstruction_order,binding.reconstruction()->integration_order_increment()); } }; include_reconstruction(row); Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_t){ include_reconstruction(*columns[Plan::templatecolumn_index<OperandT>()]); }); basis.rule=&equation_rule<EquationT>(equation,policy,transformation,displacement_element,mapping_kind,reconstruction_order); basis.reference_geometry.reserve(basis.rule->GetNPoints()); for(intpoint=0;point<basis.rule->GetNPoints();++point){ autogeometry=mapping::sample_fixed_mesh_geometry(transformation,basis.rule->IntPoint(point)); if(!geometry){ returnstd::unexpected(PreparationRejection{ PreparationRejectionReason::MAPPING,geometry.error(),element,point,"Invalidreferencemeshgeometry." }); } basis.reference_geometry.push_back(std::move(*geometry)); } BasisWorkspaceworkspace; Test::sample_basis(row,element,*basis.rule,basis.reference_test_basis,basis_cache,contraction_mode,transformation,workspace); basis.displacement_basis.sample( displacement_element,*basis.rule,ReferenceOperation::value_and_gradient,3,basis_cache,contraction_mode ); Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_tindex){ static_assert(EvaluableOperand<OperandT>,"TheMFEMoperatorhasnoevaluatorforthisoperand."); constauto&binding=*columns[Plan::templatecolumn_index<OperandT>()]; OperandEvaluator<OperandT>::sample_basis( binding,element,*basis.rule,basis.reference_operand_basis[index],basis_cache,contraction_mode,transformation,workspace ); }); returnbasis; } template<VolumeEquationEquationT,EvaluableOperandOperandT,typenameBindingT> requiresstd::same_as<typenameBindingT::Term,typenameOperandT::term_type> [[nodiscard]]::mfem::Vectorsample_element_operand( constElementBasis<EquationPlan<EquationT>::operand_count>&basis, constCoefficientView<BindingT>&input, constdiscretization::backend::mfem::DofMap::Elements&elements, Workspace&workspace ){ usingPlan=EquationPlan<EquationT>; constexprstd::size_tindex=equations::OperandValues<typenamePlan::Operands>::templateindex<OperandT>(); ::mfem::Vectorvalues; elements.element_values(basis.element,input.values,workspace.element_values); OperandEvaluator<OperandT>::evaluate(basis.reference_operand_basis[index],workspace.element_values,values,workspace.basis); returnvalues; } template<VolumeEquationEquationT,typenameContributionT> [[nodiscard]]std::expected<ElementGeometry<EquationPlan<EquationT>::operand_count>,PreparationRejection>map_element_geometry( constElementBasis<EquationPlan<EquationT>::operand_count>&basis, constdiscretization::backend::mfem::DofMap&displacement_binding, constdiscretization::backend::mfem::DofMap::Elements&displacement_elements, const::mfem::Vector&displacement, constMappingCoefficients&compactification, constmapping::DomainMapper&mapper, Workspace&workspace ){ usingPlan=EquationPlan<EquationT>; usingTest=OperandEvaluator<equations::TestOperandOf<ContributionT>>; ElementGeometry<Plan::operand_count>geometry; ifconstexpr(Test::geometry_dependent){ geometry.test_basis.reset_from(basis.reference_test_basis,Test::components); }else{ geometry.test_basis=basis.reference_test_basis; } Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_tindex){ usingEvaluator=OperandEvaluator<OperandT>; ifconstexpr(Evaluator::geometry_dependent){ geometry.operand_basis[index].reset_from(basis.reference_operand_basis[index],Evaluator::components); }else{ geometry.operand_basis[index]=basis.reference_operand_basis[index]; } }); displacement_elements.element_values(basis.element,displacement,geometry.displacement); ::mfem::Array<int>compactification_dofs; //AlocalDofTransformationkeepsconcurrentelementloopsoffthespace'ssharedone. ::mfem::DofTransformationcompactification_transform; compactification.binding.GetElementVDofs(basis.element,compactification_dofs,compactification_transform); compactification.values.GetSubVector(compactification_dofs,geometry.compactification); if(compactification_transform.GetDofTransformation()!=nullptr){ compactification_transform.InvTransformPrimal(geometry.compactification); } basis.displacement_basis.evaluate(geometry.displacement,workspace.displacement_samples,workspace.basis); constauto&displacement_element=*displacement_binding.space().GetFE(basis.element); constautodisplacement_data=mapping::element_displacement_data_from_element_vdofs(displacement_element,geometry.displacement); constmapping::ElementCompactificationDatacompactification_data( *compactification.binding.GetFE(basis.element),geometry.compactification ); constmapping::ElementMappingDatamapping_data{displacement_data,compactification_data}; ::mfem::IsoparametricTransformationtransformation; ::serif::utils::parallel::element_transformation(*displacement_binding.space().GetMesh(),basis.element,transformation); constintpoint_count=basis.rule->GetNPoints(); geometry.mapping.set_size(point_count,3); for(intpoint=0;point<point_count;++point){ for(intaxis=0;axis<3;++axis){ workspace.displacement_value[axis]=workspace.displacement_samples[12*point+4*axis]; for(intderivative=0;derivative<3;++derivative){ workspace.displacement_gradient(axis,derivative)=workspace.displacement_samples[12*point+4*axis+derivative+1]; } } constmapping::DMReferenceDisplacementSamplesample{workspace.displacement_value,workspace.displacement_gradient}; constautostatus=mapper.evaluate_volume( mapping_data,transformation,basis.rule->IntPoint(point), workspace.mapping_workspace,workspace.mapping_context,&sample,&basis.reference_geometry[point] ); if(status!=mapping::MappingStatus::VALID){ returnstd::unexpected(PreparationRejection{ PreparationRejectionReason::MAPPING,status,basis.element,point,"Invalidequationgeometry." }); } geometry.mapping.store(point,workspace.mapping_context); constauto&context=workspace.mapping_context.mapping; ifconstexpr(Test::geometry_dependent){ Test::map_basis_point(point,context,basis.reference_test_basis,geometry.test_basis,workspace.basis); } Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_tindex){ ifconstexpr(OperandEvaluator<OperandT>::geometry_dependent){ OperandEvaluator<OperandT>::map_basis_point(point,context,basis.reference_operand_basis[index],geometry.operand_basis[index],workspace.basis); } }); } returngeometry; } template<EvaluableOperandOperandT,std::size_tCount> [[nodiscard]]::mfem::Vectormap_element_operand( const::mfem::Vector&reference, constElementGeometry<Count>&geometry, Workspace&workspace ){ usingEvaluator=OperandEvaluator<OperandT>; constintpoint_count=geometry.mapping.get_point_count(); ::mfem::Vectorvalues(point_count*Evaluator::components); for(intpoint=0;point<point_count;++point){ geometry.mapping.load(point,workspace.mapping_context); constautovalue=Evaluator::physical_value( Evaluator::reference_value(reference,point),workspace.mapping_context.mapping ); for(intcomponent=0;component<Evaluator::components;++component){ values[point*Evaluator::components+component]=discretization::forms::component(value,component); } } returnvalues; } template<VolumeEquationEquationT,typenameContributionT> [[nodiscard]]equations::EquationPoint<typenameContributionT::Operands>element_equation_point( conststd::array<std::shared_ptr<const::mfem::Vector>,EquationPlan<EquationT>::operand_count>&physical_values, constmapping::MappingPointContext&context, intpoint ){ usingPlan=EquationPlan<EquationT>; equations::EquationPoint<typenameContributionT::Operands>values; Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_tindex){ usingEvaluator=OperandEvaluator<OperandT>; auto&value=values.fields.templateget<OperandT>(); for(intcomponent=0;component<Evaluator::components;++component){ discretization::forms::component(value,component)=(*physical_values[index])[point*Evaluator::components+component]; } }); for(intaxis=0;axis<3;++axis){ values.position[axis]=context.physical_position[axis]; } returnvalues; } template<VolumeEquationEquationT,typenameContributionT> [[nodiscard]]boolstore_element_linearization( constequations::PointLinearization<typenameContributionT::Operands,typenameOperandEvaluator<equations::TestOperandOf<ContributionT>>::Value>&physics, intpoint, doubleweight, ElementData<EquationPlan<EquationT>::operand_count>&data ){ usingPlan=EquationPlan<EquationT>; usingTest=OperandEvaluator<equations::TestOperandOf<ContributionT>>; usingResult=typenameTest::Value; boolfinite=true; for(intoutput=0;output<Test::components;++output){ constintrow_index=point*Test::components+output; data.weighted_residual[row_index]=weight*discretization::forms::component(physics.residual,output); finite=finite&&std::isfinite(data.weighted_residual[row_index]); Plan::templatefor_each_input<ContributionT>([&]<typenameOperandT>(OperandT,std::size_t){ usingInput=typenameOperandEvaluator<OperandT>::Value; for(intinput=0;input<OperandEvaluator<OperandT>::components;++input){ auto&derivative=data.weighted_field_derivatives(row_index,Plan::templatecomponent_offset<OperandT>()+input); derivative=weight*discretization::forms::derivative_component<Result, Input>( physics.field_derivatives.templateget<OperandT>(),output,input ); finite=finite&&std::isfinite(derivative); } }); for(intaxis=0;axis<3;++axis){ auto&derivative=data.weighted_position_derivative(row_index,axis); derivative=weight*discretization::forms::derivative_component<Result, discretization::forms::VectorValue>( physics.position_derivative,output,axis ); finite=finite&&std::isfinite(derivative); } } returnfinite; } template<VolumeEquationEquationT,typenameContributionT> [[nodiscard]]std::expected<ElementData<EquationPlan<EquationT>::operand_count>,PreparationRejection>evaluate_element_equation( constContributionT&equation, doublecoefficient, std::shared_ptr<constElementBasis<EquationPlan<EquationT>::operand_count>>basis, std::shared_ptr<constElementGeometry<EquationPlan<EquationT>::operand_count>>geometry, std::array<std::shared_ptr<const::mfem::Vector>,EquationPlan<EquationT>::operand_count>reference_values, conststd::array<std::shared_ptr<const::mfem::Vector>,EquationPlan<EquationT>::operand_count>&physical_values, Workspace&workspace ){ usingPlan=EquationPlan<EquationT>; usingTest=OperandEvaluator<equations::TestOperandOf<ContributionT>>; usingResult=typenameTest::Value; ElementData<Plan::operand_count>data{ .element=basis->element, .basis=std::move(basis), .geometry=std::move(geometry), .reference_operand_values=std::move(reference_values) }; constintpoint_count=data.basis->rule->GetNPoints(); data.weighted_residual.SetSize(point_count*Test::components); data.weighted_field_derivatives.SetSize(point_count*Test::components,Plan::component_count); data.weighted_field_derivatives=0.0; data.weighted_position_derivative.SetSize(point_count*Test::components,3); utils::CompensatedSumelement_validation; for(intpoint=0;point<point_count;++point){ data.geometry->mapping.load(point,workspace.mapping_context); constautovalues=element_equation_point<EquationT, ContributionT>( physical_values,workspace.mapping_context.mapping,point ); equations::PointLinearization<typenameContributionT::Operands,Result>physics; try{ physics=equation.evaluate(values); ifconstexpr(requires{equation.validate_integral(0.0);}){ //Physicaladmissibilityisindependentofequationarithmeticcoefficients. element_validation.add( workspace.mapping_context.quadrature.physical_integration_weight*equation.validation_integrand(values,physics) ); } }catch(conststd::domain_error&error){ returnstd::unexpected(PreparationRejection{ PreparationRejectionReason::EQUATION,mapping::MappingStatus::VALID,data.element,point,error.what() }); } //Geometryvariationsstillneedtheunscaledphysicalintegrationweight. constdoubleweight=coefficient*workspace.mapping_context.quadrature.physical_integration_weight; if(!store_element_linearization<EquationT, ContributionT>(physics,point,weight,data)){ returnstd::unexpected(PreparationRejection{ PreparationRejectionReason::NON_FINITE,mapping::MappingStatus::VALID, data.element,point,"Non-finiteequationintegrandorderivative." }); } } data.validation_integral=element_validation.value(); returndata; } }//namespaceserif::operators::backend::mfem