physics.hpp memory algorithm cmath serif/utils/serialize/components.hpp serif/dimensions/dimensions.hpp serif/eos/models/polytropic.hpp serif/model/description.hpp serif/model/eos_reference.hpp serif/geometry/surface/isobaric.hpp serif/geometry/deformation/models.hpp src/include/serif/backend/mfem/serialize/discretization.hpp src/include/serif/utils/serialize/equations.hpp serif/dimensions/dimensions.hpp serif/dimensions/partial.hpp serif/dimensions/quantities.hpp serif/dimensions/type_alias.hpp serif/eos/models/polytropic.hpp serif/eos/relations/catalog.hpp serif/eos/relations/relations.hpp serif/geometry/deformation/models.hpp serif/geometry/surface/isobaric.hpp serif/meta/enums.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/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 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/physics.hpp src/include/serif/utils/serialize/serialize.hpp src/include/serif/utils/serialize/solver.hpp serif::utils::serialize::Serializer< dimensions::QuantityValue< Quantity > > serif::utils::serialize::Serializer< eos::models::Polytrope > serif::utils::serialize::Serializer< model::EosReference< EOS > > serif::utils::serialize::Serializer< model::FixedTotalMass > serif::utils::serialize::Serializer< geometry::surface::IsobaricSurface > serif::utils::serialize::Serializer< model::FixedAngularMomentum > serif::utils::serialize::Serializer< geometry::deformation::NodalRadialSurface > serif::utils::serialize::Serializer< geometry::deformation::PowerLawRadialExtension > serif::utils::serialize::Serializer< geometry::deformation::FixedInfinityRadialExtension > serif::utils::serialize::Serializer< geometry::deformation::SphericalHarmonicSurface > serif::utils::serialize::Serializer< geometry::deformation::DomainDeformation< Surface, Interior, Vacuum > > serif serif::utils serif::utils::serialize #pragmaonce #include<memory> #include<algorithm> #include<cmath> #include"serif/utils/serialize/components.hpp" #include"serif/dimensions/dimensions.hpp" #include"serif/eos/models/polytropic.hpp" #include"serif/model/description.hpp" #include"serif/model/eos_reference.hpp" #include"serif/geometry/surface/isobaric.hpp" #include"serif/geometry/deformation/models.hpp" namespaceserif::utils::serialize{ template<dimensions::PhysicalQuantityTypeQuantity> structSerializer<dimensions::QuantityValue<Quantity>>{ usingT=dimensions::QuantityValue<Quantity>; staticconstexprstd::string_viewkey="quantity"; [[nodiscard]]staticNodesave(constT&value){ returnobject(key,field("dimension",std::string(Quantity::identifier)),field("value",value.value())); } [[nodiscard]]staticResult<T>load(constNode&node){ returnread_object(node,key,[](std::stringdimension,doublevalue){ errors::serif_ensure<errors::SERiFErrorCode::INVALID_ARGUMENT>(dimension==Quantity::identifier, "Thearchivedquantityhasdimension{},expected{}.",dimension,Quantity::identifier); returnT{value}; },member<std::string>("dimension"),member<double>("value")); } }; template<> structSerializer<eos::models::Polytrope>{ staticconstexprstd::string_viewkey="eos.polytrope"; [[nodiscard]]staticNodesave(consteos::models::Polytrope&value){ returnobject(key,field("index",value.polytropic_index()),field("constant",value.polytropic_constant())); } [[nodiscard]]staticResult<eos::models::Polytrope>load(constNode&node){ returnread_object(node,key,[](doublen,doubleK){returneos::models::Polytrope{n,K};},member<double>("index"),member<double>("constant")); } }; template<typenameEOS> structSerializer<model::EosReference<EOS>>{ staticconstexprstd::string_viewkey="eos.reference"; [[nodiscard]]staticNodesave(constmodel::EosReference<EOS>&value){returnobject(key,field("eos",value.get()));} [[nodiscard]]staticResult<model::EosReference<EOS>>load(constNode&node){ returnread_object(node,key,[](EOSeos){returnmodel::EosReference<EOS>{std::make_shared<constEOS>(std::move(eos))};},member<EOS>("eos")); } }; template<> structSerializer<model::FixedTotalMass>{ staticconstexprstd::string_viewkey="physics.fixed_total_mass"; [[nodiscard]]staticNodesave(constmodel::FixedTotalMass&value){returnobject(key,field("target",value.target()));} [[nodiscard]]staticResult<model::FixedTotalMass>load(constNode&node){ returnread_object(node,key,[](dimensions::MassValuetarget){returnmodel::FixedTotalMass{target};},member<dimensions::MassValue>("target")); } }; template<> structSerializer<geometry::surface::IsobaricSurface>{ staticconstexprstd::string_viewkey="surface.isobaric"; [[nodiscard]]staticNodesave(constgeometry::surface::IsobaricSurface&value){returnobject(key,field("target",value.target_pressure()));} [[nodiscard]]staticResult<geometry::surface::IsobaricSurface>load(constNode&node){ returnread_object(node,key,[](dimensions::PressureValuetarget){returngeometry::surface::IsobaricSurface{target};},member<dimensions::PressureValue>("target")); } }; template<> structSerializer<model::FixedAngularMomentum>{ staticconstexprstd::string_viewkey="physics.fixed_angular_momentum"; [[nodiscard]]staticNodesave(constmodel::FixedAngularMomentum&value){ returnobject(key,field("target",value.target()),field("axis",value.axis()),field("center",value.center())); } [[nodiscard]]staticResult<model::FixedAngularMomentum>load(constNode&node){ returnread_object(node,key,[](dimensions::AngularMomentumValuetarget,std::array<double,3>axis,std::array<double,3>center){ returnmodel::FixedAngularMomentum{{.angular_momentum=target,.axis=axis,.center=center}}; },member<dimensions::AngularMomentumValue>("target"),member<std::array<double, 3>>("axis"),member<std::array<double,3>>("center")); } }; template<> structSerializer<geometry::deformation::NodalRadialSurface>:StructSerializer<geometry::deformation::NodalRadialSurface>{ usingT=geometry::deformation::NodalRadialSurface; staticconstexprstd::string_viewkey="surface.nodal_radial"; staticconstexprautomembers=std::tuple{member_field("reference_center",&T::reference_center)}; [[nodiscard]]staticboolvalid(constT&value){ returnstd::ranges::all_of(value.reference_center,[](doublecomponent){returnstd::isfinite(component);}); } }; template<> structSerializer<geometry::deformation::PowerLawRadialExtension>:StructSerializer<geometry::deformation::PowerLawRadialExtension>{ usingT=geometry::deformation::PowerLawRadialExtension; staticconstexprstd::string_viewkey="extension.radial_power"; staticconstexprautomembers=std::tuple{member_field("radial_power",&T::radial_power)}; [[nodiscard]]staticboolvalid(constT&value){ returnstd::isfinite(value.radial_power)&&value.radial_power>=1.0; } }; template<> structSerializer<geometry::deformation::FixedInfinityRadialExtension>:StructSerializer<geometry::deformation::FixedInfinityRadialExtension>{ usingT=geometry::deformation::FixedInfinityRadialExtension; staticconstexprstd::string_viewkey="extension.fixed_infinity"; staticconstexprautomembers=std::tuple{}; }; template<> structSerializer<geometry::deformation::SphericalHarmonicSurface>:StructSerializer<geometry::deformation::SphericalHarmonicSurface>{ usingT=geometry::deformation::SphericalHarmonicSurface; staticconstexprstd::string_viewkey="surface.normalized_real_spherical_harmonics"; staticconstexprautomembers=std::tuple{ member_field("reference_center",&T::reference_center), member_field("maximum_degree",&T::maximum_degree), member_field("maximum_azimuthal_order",&T::maximum_azimuthal_order) }; [[nodiscard]]staticboolvalid(constT&value){ returnstd::ranges::all_of(value.reference_center,[](doublecomponent){returnstd::isfinite(component);})&&value.maximum_degree>=0&& (!value.maximum_azimuthal_order||(*value.maximum_azimuthal_order>=0&&*value.maximum_azimuthal_order<=value.maximum_degree)); } }; template<typenameSurface,typenameInterior,typenameVacuum> structSerializer<geometry::deformation::DomainDeformation<Surface,Interior,Vacuum>>:StructSerializer<geometry::deformation::DomainDeformation<Surface,Interior,Vacuum>>{ usingT=geometry::deformation::DomainDeformation<Surface, Interior, Vacuum>; staticconstexprstd::string_viewkey="deformation.domain"; staticconstexprautomembers=std::tuple{ member_field("surface",&T::surface), member_field("stellar_interior",&T::stellar_interior), member_field("vacuum",&T::vacuum) }; }; }