equations.hpp serif/utils/serialize/physics.hpp serif/equations/equations.hpp serif/equations/registry.hpp src/include/serif/utils/serialize/model.hpp serif/dimensions/dimensions.hpp serif/dimensions/partial.hpp serif/dimensions/quantities.hpp serif/dimensions/type_alias.hpp serif/discretization/blocks/base.hpp serif/discretization/blocks/concepts.hpp serif/discretization/blocks/fields.hpp serif/discretization/blocks/traits.hpp serif/discretization/domain/concepts.hpp serif/discretization/domain/physical_domains.hpp serif/discretization/domain/types.hpp serif/discretization/forms/operands.hpp serif/discretization/forms/value.hpp serif/discretization/functional_space/space.hpp serif/eos/evaluation.hpp serif/eos/exceptions.hpp serif/eos/models/concepts.hpp serif/eos/models/polytropic.hpp serif/eos/models/traits.hpp serif/eos/relations/catalog.hpp serif/eos/relations/concepts.hpp serif/eos/relations/relations.hpp serif/eos/relations/traits.hpp serif/equations/angular_momentum.hpp serif/equations/barotropic_density.hpp serif/equations/barycenter.hpp serif/equations/companion.hpp serif/equations/concepts.hpp serif/equations/contributions.hpp serif/equations/equations.hpp serif/equations/mass_normalization.hpp serif/equations/point.hpp serif/equations/primal_gravity.hpp serif/equations/registry.hpp serif/equations/rigid_rotation.hpp serif/equations/surface_potential.hpp serif/geometry/deformation/models.hpp serif/geometry/surface/isobaric.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/model/description.hpp serif/model/detail/specification_list.hpp serif/model/eos_reference.hpp serif/model/equilibrium_equations.hpp serif/model/specification.hpp serif/model/specifications/fixed_angular_momentum.hpp serif/model/specifications/fixed_total_mass.hpp serif/model/specifications/physical_names.hpp serif/model/stellar_model.hpp serif/utils/error/codes.hpp serif/utils/error/errors.hpp serif/utils/misc/concepts/exceptions.hpp serif/utils/misc/concepts/filter.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/serialize/components.hpp src/include/serif/utils/serialize/equations.hpp serif/utils/serialize/physics.hpp serif/utils/serialize/record.hpp serif/utils/types/strings.hpp serif/utils/types/type_list.hpp algorithm array bit cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional iostream limits magic_enum/magic_enum_all.hpp map memory nameof.hpp numeric optional span stdexcept string string_view tuple type_traits unistd.h unordered_map utility variant vector version src/compile_time_checks/serif/backend_independent.cpp src/include/serif/backend/mfem/serialize/configuration.hpp src/include/serif/backend/mfem/serialize/discretization.hpp src/include/serif/backend/mfem/serialize/options.hpp src/include/serif/utils/serialize/equations.hpp src/include/serif/utils/serialize/model.hpp src/include/serif/utils/serialize/numerics.hpp src/include/serif/utils/serialize/serialize.hpp src/include/serif/utils/serialize/solver.hpp serif::utils::serialize::Serializer< equations::BarycenterConstraint< Axis, Row > > serif::utils::serialize::Serializer< equations::PointMassCompanion > serif::utils::serialize::Serializer< equations::BarotropicDensityBalance< EOS > > serif::utils::serialize::Serializer< equations::PrimalPoissonBalance > serif::utils::serialize::Serializer< equations::SurfacePotentialBalance > serif::utils::serialize::Serializer< equations::MassNormalization > serif::utils::serialize::Serializer< equations::AngularMomentumConstraint > serif::utils::serialize::Serializer< equations::EquationRegistry< Equations... > > serif serif::utils serif::utils::serialize serif::utils::serialize::detail #pragmaonce #include"serif/utils/serialize/physics.hpp" #include"serif/equations/equations.hpp" #include"serif/equations/registry.hpp" namespaceserif::utils::serialize{ template<intAxis,typenameRow> structSerializer<equations::BarycenterConstraint<Axis,Row>>{ usingT=equations::BarycenterConstraint<Axis, Row>; staticconstexprstd::string_viewkey=std::same_as<Row,discretization::blocks::frame_acceleration::component<Axis>> ?std::array<std::string_view,3>{"equation.barycenter.x","equation.barycenter.y","equation.barycenter.z"}[Axis] :std::array<std::string_view,3>{"equation.orbital_barycenter.x","equation.orbital_barycenter.y","equation.orbital_barycenter.z"}[Axis]; [[nodiscard]]staticNodesave(constT&value){returnobject(key,field("target_mass",value.target_mass()),field("center",value.center()));} [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](doublemass,std::array<double,3>center){returnT{mass,center};}, member<double>("target_mass"),member<std::array<double, 3>>("center")); } }; template<> structSerializer<equations::PointMassCompanion>{ usingT=equations::PointMassCompanion; staticconstexprstd::string_viewkey="equation.point_mass_companion"; [[nodiscard]]staticNodesave(constT&value){ returnobject(key,field("gravitational_mass",value.gravitational_mass()),field("position",value.position()), field("tidal_only",value.tidal_only())); } [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](doublemass,std::array<double,3>position,booltidal_only){returnT{mass,position,tidal_only};}, member<double>("gravitational_mass"),member<std::array<double, 3>>("position"),member<bool>("tidal_only")); } }; namespacedetail{ [[nodiscard]]inlineResult<std::optional<equations::PointMassCompanion>>read_companion(constNode&node){ if(!node.children.contains("companion")){returnstd::optional<equations::PointMassCompanion>{};} autocompanion=read_field<equations::PointMassCompanion>(node,"companion"); if(!companion){returnstd::unexpected(companion.error());} returnstd::optional<equations::PointMassCompanion>{*companion}; } inlineNodewith_companion(Nodenode,conststd::optional<equations::PointMassCompanion>&companion){ if(companion){node.children.emplace("companion",encode(*companion));} returnnode; } } template<typenameEOS> structSerializer<equations::BarotropicDensityBalance<EOS>>{ usingT=equations::BarotropicDensityBalance<EOS>; staticconstexprstd::string_viewkey="equation.barotropic_density"; [[nodiscard]]staticNodesave(constT&value){ returndetail::with_companion(object(key,field("eos",value.equation_of_state()),field("surface_pressure",value.surface_pressure()), field("axis",value.rotation().angular_velocity_vector()),field("center",value.rotation().axis_origin())),value.companion()); } [[nodiscard]]staticResult<T>load(constNode&node){ constautocompanion=detail::read_companion(node); if(!companion){returnstd::unexpected(companion.error());} returnread_object(node,key,[&](EOSeos,dimensions::PressureValuepressure,std::array<double,3>axis,std::array<double,3>center){ returnT{std::move(eos),pressure,axis,center,*companion}; },member<EOS>("eos"),member<dimensions::PressureValue>("surface_pressure"), member<std::array<double, 3>>("axis"),member<std::array<double,3>>("center")); } }; template<> structSerializer<equations::PrimalPoissonBalance>{ usingT=equations::PrimalPoissonBalance; staticconstexprstd::string_viewkey="equation.primal_poisson"; [[nodiscard]]staticNodesave(constT&value){returnobject(key,field("four_pi_G",value.four_pi_G()));} [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](doublevalue){returnT{value};},member<double>("four_pi_G")); } }; template<> structSerializer<equations::SurfacePotentialBalance>{ usingT=equations::SurfacePotentialBalance; staticconstexprstd::string_viewkey="equation.surface_potential"; [[nodiscard]]staticNodesave(constT&value){ returndetail::with_companion(object(key,field("axis",value.rotation().angular_velocity_vector()), field("center",value.rotation().axis_origin())),value.companion()); } [[nodiscard]]staticResult<T>load(constNode&node){ constautocompanion=detail::read_companion(node); if(!companion){returnstd::unexpected(companion.error());} returnread_object(node,key,[&](std::array<double,3>axis,std::array<double,3>center){returnT{axis,center,*companion};}, member<std::array<double, 3>>("axis"),member<std::array<double, 3>>("center")); } }; template<> structSerializer<equations::MassNormalization>{ usingT=equations::MassNormalization; staticconstexprstd::string_viewkey="equation.mass_normalization"; [[nodiscard]]staticNodesave(constT&value){returnobject(key,field("mass",-value.residual_offset()));} [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](doublevalue){returnT{value};},member<double>("mass")); } }; template<> structSerializer<equations::AngularMomentumConstraint>{ usingT=equations::AngularMomentumConstraint; staticconstexprstd::string_viewkey="equation.angular_momentum"; [[nodiscard]]staticNodesave(constT&value){ returnobject(key,field("target",-value.residual_offset()),field("axis",value.rotation().angular_velocity_vector()),field("center",value.rotation().axis_origin())); } [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](doubletarget,std::array<double,3>axis,std::array<double,3>center){returnT{target,axis,center};}, member<double>("target"),member<std::array<double, 3>>("axis"),member<std::array<double,3>>("center")); } }; template<typename...Equations> structSerializer<equations::EquationRegistry<Equations...>>{ usingT=equations::EquationRegistry<Equations...>; staticconstexprstd::string_viewkey="equations.registry"; [[nodiscard]]staticNodesave(constT&value){returnobject(key,field("equations",std::tie(value.templateget<Equations>()...)));} [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](std::tuple<Equations...>equations){ returnstd::apply([](auto&&...values){returnT{std::move(values)...};},std::move(equations)); },member<std::tuple<Equations...>>("equations")); } }; }