discretization.hpp optional tuple type_traits serif/backend/mfem/model/discretization.hpp serif/backend/mfem/serialize/resources.hpp serif/utils/serialize/model.hpp serif/utils/serialize/physics.hpp src/include/serif/backend/mfem/serialize/configuration.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/resources.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/geometry/deformation/inputs.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/variation.hpp serif/backend/mfem/mapping/volume_cache.hpp serif/backend/mfem/model/discretization.hpp serif/backend/mfem/operators/element_data.hpp serif/backend/mfem/operators/quadrature.hpp serif/backend/mfem/operators/volume_data.hpp serif/backend/mfem/operators/workspace.hpp src/include/serif/backend/mfem/serialize/discretization.hpp serif/backend/mfem/serialize/resources.hpp serif/backend/mfem/shared/reference_tracking.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/runtime.hpp serif/discretization/blocks/system_layout.hpp serif/discretization/blocks/traits.hpp serif/discretization/blocks/vector_view.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/schemas.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/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/actions.hpp serif/geometry/deformation/composition.hpp serif/geometry/deformation/computations.hpp serif/geometry/deformation/detail/action_storage.hpp serif/geometry/deformation/failure.hpp serif/geometry/deformation/linearization.hpp serif/geometry/deformation/models.hpp serif/geometry/deformation/spaces.hpp serif/geometry/deformation/workspace.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/state.hpp serif/model/stellar_model.hpp serif/operators/concepts.hpp serif/operators/plan.hpp serif/utils/dependencies/binding.hpp serif/utils/dependencies/computation.hpp serif/utils/dependencies/computation_graph.hpp serif/utils/dependencies/dependency_context.hpp serif/utils/dependencies/detail/graph.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/concepts/concat.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 serif/utils/serialize/equations.hpp serif/utils/serialize/model.hpp serif/utils/serialize/physics.hpp serif/utils/serialize/record.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 bit cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional initializer_list iostream limits magic_enum/magic_enum_all.hpp map 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/gridfunc.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 ranges span stdexcept string string_view tuple type_traits unistd.h unordered_map utility variant vector version src/include/serif/backend/mfem/serialize/configuration.hpp src/include/serif/backend/mfem/serialize/discretization.hpp serif::utils::serialize::Serializer< model::backend::mfem::StellarDiscretization< Owner, Bindings, Deformation > > serif::backend::mfem::serialize::detail::OwnedBindings serif serif::backend serif::backend::mfem serif::backend::mfem::serialize serif::backend::mfem::serialize::detail serif::utils serif::utils::serialize #pragmaonce #include<optional> #include<tuple> #include<type_traits> #include"serif/backend/mfem/model/discretization.hpp" #include"serif/backend/mfem/serialize/resources.hpp" #include"serif/utils/serialize/model.hpp" #include"serif/utils/serialize/physics.hpp" namespaceserif::backend::mfem::serialize{ namespacedetail{ usingdiscretization::backend::mfem::OwnedBindings; template<typenameSchema> [[nodiscard]]utils::serialize::Nodedomain_schema(){ usingnamespaceutils::serialize; std::vector<Node>domains; std::vector<Node>boundaries; for(constauto&descriptor:Schema::domain_descriptors()){ domains.push_back(object("mfem.domain",field("name",descriptor.name),field("attribute",descriptor.ID))); } for(constauto&descriptor:Schema::boundary_descriptors()){ boundaries.push_back(object("mfem.boundary",field("name",descriptor.name),field("attribute",descriptor.ID))); } returnobject("mfem.schema",field("domains",domains),field("boundaries",boundaries)); } template<typenameKey,typenameContext,typenameKeys> [[nodiscard]]utils::serialize::Result<void>restore_binding(constutils::serialize::Node&node,OwnedBindings<Context, Keys>&owner){ usingnamespaceutils::serialize; usingBinding=typenameOwnedBindings<Context, Keys>::templateBinding<Key>; autoterm=read_field<Node>(node,"term"); autoschema=read_field<Node>(node,"schema"); autocoordinates=read_field<Node>(node,"coordinates"); if(node.type!="mfem.term_binding"|| (node.version!=1&&node.version!=2)|| (node.version==2)!=node.children.contains("reconstruction")||!term||!schema||!coordinates||*term!=term_schema<Key>()|| *schema!=domain_schema<typename Binding::Schema>()||term->type=="unsupported"){ returnstd::unexpected(Error{"bindings","Savedtermordomainidentitydoesnotmatchtherequestedtypeddiscretization."}); } std::unique_ptr<Binding>binding; ifconstexpr(discretization::blocks::SpatialTerm<Key>){ autoindex=read_field<std::uint64_t>(node,"space"); if(!index||*index>=owner.resources.spaces.size()){ returnstd::unexpected(Error{"bindings/space","Termspaceismissingoroutsidetherestoredresourcetable."}); } binding=std::make_unique<Binding>(*owner.resources.spaces[*index]); if(constautosaved=node.children.find("reconstruction");saved!=node.children.end()){ ifconstexpr(!std::same_as<Key,discretization::blocks::density::mass>){ returnstd::unexpected(Error{"bindings/reconstruction","Surface-powerreconstructionsupportsonlymassdensity."}); }else{ constauto&representation=saved->second; autoexponent=read_field<double>(representation,"density_exponent"); autoboundary=read_field<std::string>(representation,"boundary"); if(representation.type!="mfem.surface_power"||representation.version!=1||!exponent||!boundary){ returnstd::unexpected(Error{"bindings/reconstruction","Unknownorincompletereconstruction;itsnumericalinterpretationcannotberestored."}); } constdiscretization::reconstruction::SurfacePower<Key>specification{ .density_exponent=*exponent,.region={*boundary}}; autoplan=discretization::backend::mfem::make_reconstruction(specification,*binding); binding=std::make_unique<Binding>(*owner.resources.spaces[*index],std::move(plan)); } } }else{ if(node.children.contains("reconstruction")){ returnstd::unexpected(Error{"bindings/reconstruction","Globalscalarfieldscannotcarryspatialreconstruction."}); } autoindex=read_field<std::uint64_t>(node,"mesh"); if(!index||*index>=owner.resources.meshes.size()){ returnstd::unexpected(Error{"bindings/mesh","Globalscalarmeshismissingoroutsidetherestoredresourcetable."}); } binding=std::make_unique<Binding>(*owner.resources.meshes[*index]); } if(*coordinates!=binding_coordinates(*binding)){ returnstd::unexpected(Error{"bindings/coordinates","Termdomainsupportorreducedcoefficientnumberingchangedduringreconstruction."}); } std::get<utils::dependencies::key_index<Key,Keys>()>(owner.bindings)=std::move(binding); return{}; } } template<typenameOriginal> usingRestoredDiscretization=model::backend::mfem::StellarDiscretization< detail::OwnedBindings<std::remove_cvref_t<decltype(std::declval<Original>().term_bindings)>>, decltype(std::declval<detail::OwnedBindings<std::remove_cvref_t<decltype(std::declval<Original>().term_bindings)>>>().context()), std::remove_cvref_t<decltype(std::declval<Original>().deformation)>>; template<typenameOwner,typenameBindings,typenameDeformation> [[nodiscard]]utils::serialize::Nodesave_discretization(constmodel::backend::mfem::StellarDiscretization<Owner, Bindings, Deformation>&value, SaveOptionsoptions={}){ usingnamespaceutils::serialize; ResourceWriterresources(options); Nodebindings{.type="array"}; [&]<typename...Keys>(utils::dependencies::KeyList<Keys...>){ std::size_tindex=0; ([&]{ usingBinding=std::remove_cvref_t<decltype(value.templatebinding<Keys>())>; constauto&binding=value.templatebinding<Keys>(); Noderecord=object("mfem.term_binding",field("term",term_schema<Keys>()), field("schema",detail::domain_schema<typename Binding::Schema>()),field("coordinates",binding_coordinates(binding))); ifconstexpr(discretization::blocks::SpatialTerm<Keys>){ record.children.emplace("space",encode(resources.space(binding.space()))); if(constauto&reconstruction=binding.reconstruction()){ //Version2preventsoldreadersfromsilentlytreatingweightedcoefficientsasordinarypolynomials. record.version=2; constauto*profile=dynamic_cast<constdiscretization::reconstruction::SurfacePowerProfile*>(&reconstruction->profile()); utils::errors::serif_ensure<utils::errors::SERiFErrorCode::INVALID_ARGUMENT>(profile!=nullptr, "Reconstruction'{}'hasnoarchivecodec;addonebeforesavingthisfield.",reconstruction->profile().name()); std::stringboundary_name; for(constauto&boundary:Binding::Schema::boundary_descriptors()){ if(boundary.ID==reconstruction->boundary_attribute()){boundary_name=boundary.name;} } utils::errors::serif_ensure<utils::errors::SERiFErrorCode::INVALID_ARGUMENT>(!boundary_name.empty(), "Cannotsaveareconstructionwhoseboundaryisabsentfromthefield'sschema."); record.children.emplace("reconstruction",object("mfem.surface_power", field("density_exponent",profile->density_exponent()),field("boundary",boundary_name))); } }else{ record.children.emplace("mesh",encode(resources.mesh(binding.mesh()))); } bindings.children.emplace(std::to_string(index++),std::move(record)); }(),...); }(typenameBindings::Keys{}); resources.mapping(value.compactification,value.mapper); Noderesult=object("mfem.stellar_discretization",field("bindings",bindings)); ifconstexpr(std::same_as<Deformation,model::backend::mfem::NoDeformation>){ result.children.emplace("deformation",Node{.type="mfem.no_deformation"}); }else{ result.children.emplace("deformation",encode(value.deformation.model)); result.children.emplace("reference",resources.reference(value.deformation.reference)); } result.children.emplace("resources",std::move(resources).finish()); returnresult; } template<typenameOriginal> [[nodiscard]]utils::serialize::Result<RestoredDiscretization<Original>>restore_discretization(constutils::serialize::Node&node, constMeshResolver&resolver={}){ usingnamespaceutils::serialize; usingContext=std::remove_cvref_t<decltype(std::declval<Original>().term_bindings)>; usingDeformation=std::remove_cvref_t<decltype(std::declval<Original>().deformation)>; if(node.type!="mfem.stellar_discretization"||node.version!=1){ returnstd::unexpected(Error{"discretization","UnsupportedMFEMstellardiscretizationschema."}); } try{ autoresources_node=read_field<Node>(node,"resources"); //Inspecteachbindingversionlocally;genericvectordecodingonlyacceptsversion-1children. autobindings=read_field<Node>(node,"bindings"); if(!resources_node||!bindings||bindings->type!="array"||!std::holds_alternative<std::monostate>(bindings->value)||bindings->children.size()!=utils::dependencies::key_count_v<typename Context::Keys>){ returnstd::unexpected(Error{"discretization","Missingresourcesorincompatibleterm-bindingcount."}); } autoresources=restore_resources(*resources_node,resolver); if(!resources){ returnstd::unexpected(resources.error()); } autoowner=std::make_shared<detail::OwnedBindings<Context>>(); owner->resources=std::move(*resources); std::optional<Error>error; [&]<typename...Keys>(utils::dependencies::KeyList<Keys...>){ std::size_tindex=0; ([&]{ if(!error){ constautosaved=bindings->children.find(std::to_string(index)); if(saved==bindings->children.end()){ error=Error{"bindings","Term-bindingarrayindicesarenotcontiguous."}; }else{ autostatus=detail::restore_binding<Keys>(saved->second,*owner); if(!status){error=status.error();} } } ++index; }(),...); }(typenameContext::Keys{}); if(error){ returnstd::unexpected(*error); } autobase=model::backend::mfem::make_stellar_discretization(owner,owner->context(),*owner->resources.compactification,*owner->resources.mapper); autodeformation=read_field<Node>(node,"deformation"); if(!deformation){ returnstd::unexpected(deformation.error()); } ifconstexpr(std::same_as<Deformation,model::backend::mfem::NoDeformation>){ if(deformation->type!="mfem.no_deformation"){ returnstd::unexpected(Error{"deformation","Savedshaperepresentationdiffersfromtherequestedfixed-geometrydiscretization."}); } returnbase; }else{ usingDomainModel=std::remove_cvref_t<decltype(std::declval<Deformation>().model)>; autodeformation_model=decode<DomainModel>(*deformation); autoreference_node=read_field<Node>(node,"reference"); if(!deformation_model||!reference_node){ returnstd::unexpected(Error{"deformation","Missingorunsupportedsurface/extensionprescriptionorreferencegeometry."}); } autoreference=restore_reference(*reference_node,owner->resources); if(!reference){ returnstd::unexpected(reference.error()); } returnmodel::backend::mfem::with_deformation(std::move(base),std::move(*deformation_model),std::move(*reference)); } }catch(conststd::exception&error){ returnstd::unexpected(Error{"discretization","Savednumericalinterpretationisinvalid:"+std::string{error.what()}}); } } } namespaceserif::utils::serialize{ template<typenameOwner,typenameBindings,typenameDeformation> structSerializer<model::backend::mfem::StellarDiscretization<Owner,Bindings,Deformation>>{ usingDiscretization=model::backend::mfem::StellarDiscretization<Owner, Bindings, Deformation>; staticconstexprstd::string_viewkey="discretization"; staticNodesave(constmodel::backend::mfem::StellarDiscretization<Owner, Bindings, Deformation>&value){ returnserif::backend::mfem::serialize::save_discretization(value); } staticResult<Discretization>load(constNode&){ returnstd::unexpected(Error{"discretization","Useserif::backend::mfem::serialize::restore_discretization<Original>(node)toreconstructanindependentlyownednumericaldiscretization."}); } }; }