equilibrium.hpp expected serif/model/backend/mfem/binding.hpp serif/model/backend/mfem/configured_discretization.hpp serif/model/normalization/computations.hpp serif/model/backend/mfem/discretization.hpp serif/model/backend/mfem/failure.hpp serif/model/backend/mfem/problem.hpp serif/model/graph.hpp serif/model/execution_validation.hpp serif/model/stellar_model.hpp serif/utils/checks/finite.hpp serif::model::backend::mfem::StellarEquilibrium serif serif::model serif::model::backend serif::model::backend::mfem #pragmaonce #include<expected> #include"serif/model/backend/mfem/binding.hpp" #include"serif/model/backend/mfem/configured_discretization.hpp" #include"serif/model/normalization/computations.hpp" #include"serif/model/backend/mfem/discretization.hpp" #include"serif/model/backend/mfem/failure.hpp" #include"serif/model/backend/mfem/problem.hpp" #include"serif/model/graph.hpp" #include"serif/model/execution_validation.hpp" #include"serif/model/stellar_model.hpp" #include"serif/utils/checks/finite.hpp" namespaceserif::model::backend::mfem{ template<typenameBound,typenameProblem,typenameAdditionalInputs=utils::dependencies::DependencyContext<>,typenamePreparedKey=keys::PhysicalSystem> classStellarEquilibriumfinal{ public: usingPlan=typenameBound::Plan; usingSurfaceFormulation=typenamePlan::Surface::Formulation; usingPrepared=std::remove_cvref_t<decltype(std::declval<consttypenameProblem::Cache&>().templateget<PreparedKey>())>; StellarEquilibrium(std::shared_ptr<constBound>bound,Problemproblem,AdditionalInputsadditional=AdditionalInputs{}): m_bound(std::move(bound)),m_problem(std::move(problem)),m_additional(std::move(additional)){ } template<typenameCoefficients,typenameGeometry> [[nodiscard]]autotry_prepare(constCoefficients&coefficients,constGeometry&geometry, utils::dependencies::PreparationModemode=utils::dependencies::PreparationMode::reuse_unchanged){ constautoresult=m_problem.try_prepare_inputs([&]()->std::expected<typenameProblem::InputContext,EquilibriumFailure>{ constboolfinite=[&]<typename...Terms>(utils::dependencies::KeyList<Terms...>){ return(utils::checks::is_finite(coefficients.templateget<Terms>().values)&&...); }(typenamePlan::Coefficients{}); if(!finite){ returnstd::unexpected(EquilibriumFailure{operators::backend::mfem::PreparationRejection{ .reason=operators::backend::mfem::PreparationRejectionReason::NON_FINITE, .message="Astellarcandidatecontainsanon-finitephysicalcoefficient.Supplyfinitefieldandscalarvaluesbeforepreparingit." }}); } returnutils::dependencies::combine_dependency_contexts(equilibrium_inputs(*m_bound,coefficients,geometry),m_additional); },utils::dependencies::KeyList<PreparedKey>{},mode); if(result){ m_prepared=m_problem.cache().templateget<PreparedKey>(); } returnresult; } [[nodiscard]]conststd::shared_ptr<constAcceptedSystem>&accepted()const{ returnm_problem.accepted(); } [[nodiscard]]constPrepared&prepared()const{ usingnamespaceutils::errors; serif_ensure<SERiFErrorCode::INVALID_ARGUMENT>(m_prepared!=nullptr,"Thestellarequilibriumhasnocompletepreparation.Successfullyprepareacandidatebeforerequestingsolvercoordinates."); returnm_prepared; } [[nodiscard]]constauto&layout()constnoexcept{ returnm_problem.layout(); } [[nodiscard]]constauto&cache()constnoexcept{ returnm_problem.cache(); } [[nodiscard]]constauto&model()constnoexcept{ return*m_bound->model; } private: std::shared_ptr<constBound>m_bound; Problemm_problem; AdditionalInputsm_additional; Preparedm_prepared{}; }; template<utils::dependencies::IsKeyListPrescribed=utils::dependencies::KeyList<>, utils::dependencies::IsBindingsSpecificationMap=DefaultSpecificationBindings, utils::dependencies::IsKeyListExplicitZeroCouplings=utils::dependencies::KeyList<>,StellarModelTypeModel, typenameDiscretization,typenameCoefficients,typenameGeometry> [[nodiscard]]autobind_stellar_model(Modelmodel,Discretizationdiscretization,constCoefficients&coefficients, constGeometry&geometry,operators::backend::mfem::VolumeOptionsoptions={}){ constautomodel_owner=std::make_shared<constModel>(std::move(model)); constautodiscretization_owner=std::make_shared<constDiscretization>(std::move(discretization)); constautobound=bind_model_definition<Prescribed>(model_owner,discretization_owner,coefficients); usingBound=typenamedecltype(bound)::element_type; usingPlan=typenameBound::Plan; static_assert(executable_model_topology<Model, typename Bound::Description, Plan, SpecificationMap, ExplicitZeroCouplings>(), "Theselectedmodelbackendneedsthedeclaredprescriptioncoordinates,constraintequations,andexplicitgenerated-coordinateeffects.Supplytheirequationsorauthor-registerknownzeroeffects;thischeckdoesnotprovemathematicalclosure."); constautolayout=equilibrium_layout<Plan>(*discretization_owner,geometry); autograph=make_equilibrium_graph(bound,layout,std::tuple{},options); constautoinputs=equilibrium_inputs(*bound,coefficients,geometry); autoproblem=make_stellar_problem<EquilibriumFailure>(std::move(graph),inputs,layout); returnStellarEquilibrium<std::remove_const_t<Bound>,decltype(problem)>(bound,std::move(problem)); } template<utils::dependencies::IsKeyListPrescribed=utils::dependencies::KeyList<>, utils::dependencies::IsBindingsSpecificationMap=DefaultSpecificationBindings, utils::dependencies::IsKeyListExplicitZeroCouplings=utils::dependencies::KeyList<>,StellarModelTypeModel, typenameDiscretization,typenameOptions,typenameCoefficients,typenameGeometry> [[nodiscard]]autobind_stellar_model(ConfiguredDiscretization<Model,Discretization,Options>configuration, constCoefficients&coefficients,constGeometry&geometry,operators::backend::mfem::VolumeOptionsoptions={}){ constautomodel_owner=std::make_shared<constModel>(std::move(configuration.model)); constautodiscretization_owner=std::make_shared<constDiscretization>(std::move(configuration.finite_elements)); constautobound=bind_model_definition<Prescribed>(model_owner,discretization_owner,coefficients); usingBound=typenamedecltype(bound)::element_type; usingPlan=typenameBound::Plan; usingNormalizationPlan=normalization::PlanFor<decltype(configuration.normalization.plan),decltype(configuration.normalization.coordinates),Bound>; static_assert(executable_model_topology<Model, typename Bound::Description, Plan, SpecificationMap, ExplicitZeroCouplings>(), "Theconfiguredmodelneedscompleteequationandprescriptionbindings,includingexplicitlyknownzeroeffects."); constautolayout=equilibrium_layout<Plan>(*discretization_owner,geometry); static_assert(solver::normalization::NormalizationPreparable<NormalizationPlan,decltype(layout)>, "Thenormalizationplanmustprovideonecompatibleruleforeveryunknownandresidualrow."); constautonumerical_options=std::make_shared<constOptions>(std::move(configuration.normalization)); constautometrics=normalization::MetricsFor<NormalizationPlan>{}; constautoadditional=normalization::make_inputs(numerical_options,*discretization_owner,metrics); constautonumerical=normalization::make_computations<NormalizationPlan>(*bound,*numerical_options,layout,metrics); autograph=make_equilibrium_graph(bound,layout,numerical,options); constautoinputs=utils::dependencies::combine_dependency_contexts(equilibrium_inputs(*bound,coefficients,geometry),additional); autoproblem=make_stellar_problem<EquilibriumFailure>(std::move(graph),inputs,layout); returnStellarEquilibrium<std::remove_const_t<Bound>,decltype(problem),std::remove_cvref_t<decltype(additional)>,normalization::PreparedSystem>( bound,std::move(problem),additional); } }