description.cpp concepts memory tuple serif/model/description.hpp serif/model/eos_reference.hpp src/compile_time_checks/serif/model/description.cpp serif/dimensions/dimensions.hpp serif/dimensions/quantities.hpp serif/dimensions/type_alias.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/std_helper/cleaning.hpp serif/utils/misc/terminal/colors.hpp serif/utils/types/strings.hpp serif/utils/types/type_list.hpp algorithm array compare concepts cstdint cstdio cstdlib exception format functional iostream limits magic_enum/magic_enum_all.hpp memory span stdexcept string string_view tuple type_traits unistd.h unordered_map utility version #include<concepts> #include<memory> #include<tuple> #include"serif/model/description.hpp" #include"serif/model/eos_reference.hpp" namespace { namespacemodel=serif::model; namespacedimensions=serif::dimensions; structSymbolicEOS{}; structOtherSymbolicEOS{}; usingEquations=model::EquilibriumEquations<int>; structBoundary { usingModelDefinition=model::SpecificationDefinition<Boundary,"Boundary",model::SpecificationRole::boundary_condition>; }; structOtherBoundary { usingModelDefinition=model::SpecificationDefinition<OtherBoundary,"OtherBoundary",model::SpecificationRole::boundary_condition>; }; structSemanticCollision { usingModelDefinition=model::SpecificationDefinition<SemanticCollision,"FixedTotalMass",model::SpecificationRole::invariant, model::GeneratedStateKind::physical_coordinate>; }; structSameNameDifferentRole { usingModelDefinition=model::SpecificationDefinition<SameNameDifferentRole,"FixedTotalMass",model::SpecificationRole::boundary_condition>; }; template<model::SpecificationRoleRole,model::GeneratedStateKindKind> structRoleChoice { usingModelDefinition=model::SpecificationDefinition<RoleChoice,"rolechoice",Role,Kind>; }; template<model::SpecificationRoleRole> constevalstd::array<bool,4>admitted_states() { usingKind=model::GeneratedStateKind; return{model::ModelSpecification<RoleChoice<Role,Kind::none>>,model::ModelSpecification<RoleChoice<Role,Kind::multiplier>>, model::ModelSpecification<RoleChoice<Role,Kind::physical_coordinate>>,model::ModelSpecification<RoleChoice<Role,Kind::solver_border>>}; } structInvalidRole { usingModelDefinition=model::SpecificationDefinition<InvalidRole,"invalid",model::SpecificationRole::invariant>; }; structWrongOwner { usingModelDefinition=model::SpecificationDefinition<Boundary,"wrong",model::SpecificationRole::boundary_condition>; }; structMalformed { usingModelDefinition=int; }; structIndependentUnits { usingScalarDescription=model::ScalarConstraint<dimensions::SpecificEnergy,dimensions::Dimensionless,dimensions::Mass, "custom.coordinate","x","custom.residual","F">; usingModelDefinition=model::SpecificationDefinition<IndependentUnits,"independent",model::SpecificationRole::invariant, model::GeneratedStateKind::physical_coordinate,ScalarDescription>; ScalarDescription::TargetValuetarget()const; }; structIncorrectTarget { usingModelDefinition=model::SpecificationDefinition<IncorrectTarget,"wrongunits",model::SpecificationRole::invariant, model::GeneratedStateKind::physical_coordinate,IndependentUnits::ScalarDescription>; dimensions::MassValuetarget()const; }; usingFirst=decltype(model::StellarModel(std::declval<SymbolicEOS>(),std::declval<Equations>(),std::declval<model::FixedTotalMass>(),std::declval<model::FixedAngularMomentum>())); usingReordered=decltype(model::StellarModel(std::declval<SymbolicEOS>(),std::declval<Equations>(),std::declval<model::FixedAngularMomentum>(),std::declval<model::FixedTotalMass>())); usingQualified=decltype(model::StellarModel(std::declval<constSymbolicEOS&>(),std::declval<constEquations&>(),std::declval<constmodel::FixedTotalMass&>(),std::declval<constmodel::FixedAngularMomentum&>())); usingTwoBoundaries=decltype(model::StellarModel(SymbolicEOS{},Equations{1},Boundary{},OtherBoundary{})); usingNoBoundary=decltype(model::StellarModel(SymbolicEOS{},Equations{1})); template<typenameCandidate> conceptCanResolveTemporary=requires{model::resolve_equilibrium_equations(std::declval<Candidate>());}; template<typenameCandidate> conceptCanResolveDescription=requires(constCandidate&candidate){model::resolve_equilibrium_equations(candidate);}; template<typenameCandidate> conceptCanReadUniqueBoundary=requires(constCandidate&candidate){candidate.templatespecification_for_role<model::SpecificationRole::boundary_condition>();}; static_assert(!CanResolveTemporary<First>); static_assert(!CanResolveDescription<int>); usingNotEquations=decltype(model::StellarModel(SymbolicEOS{},5)); static_assert(!CanResolveDescription<NotEquations>); static_assert(std::same_as<First,Reordered>&&std::same_as<First,Qualified>); static_assert(model::StellarModelType<NoBoundary>&&model::StellarModelType<TwoBoundaries>); static_assert(model::specification_role_count<model::SpecificationRole::boundary_condition,TwoBoundaries>==2); static_assert(!model::HasUniqueSpecificationForRole<model::SpecificationRole::boundary_condition,TwoBoundaries>); static_assert(!CanReadUniqueBoundary<TwoBoundaries>&&!CanReadUniqueBoundary<NoBoundary>); static_assert(CanReadUniqueBoundary<decltype(model::StellarModel(SymbolicEOS{},Equations{1},Boundary{}))>); static_assert(std::same_as<decltype(std::declval<constTwoBoundaries&>().specifications_for_role<model::SpecificationRole::boundary_condition>()),std::tuple<constBoundary&,constOtherBoundary&>>); static_assert(model::specification_role_count<model::SpecificationRole::boundary_condition,int>==0); static_assert(!model::StellarModelType<model::StellarModel<int,int,int>>); static_assert(!model::ModelSpecification<int>&&!model::ModelSpecification<WrongOwner>&&!model::ModelSpecification<Malformed>); static_assert(!model::ModelSpecification<InvalidRole>); static_assert(!model::ValidSpecificationPack<model::FixedTotalMass,SemanticCollision>); static_assert(model::ValidSpecificationPack<model::FixedTotalMass,SameNameDifferentRole>); static_assert(!model::ValidSpecificationPack<model::FixedTotalMass,model::FixedTotalMass>); static_assert(!model::ValidSpecificationPack<int>); static_assert(model::DimensionalScalarSpecification<IndependentUnits>); static_assert(!model::DimensionalScalarSpecification<IncorrectTarget>); static_assert(std::same_as<model::GeneratedCoordinateQuantity<IndependentUnits>,dimensions::Dimensionless>); static_assert(std::same_as<model::ConstraintQuantity<IndependentUnits>,dimensions::Mass>); static_assert(std::same_as<model::GeneratedCoordinateQuantity<model::FixedAngularMomentum>,dimensions::AngularVelocity>); static_assert(!std::same_as<model::GeneratedCoordinateOf<model::FixedTotalMass>,model::GeneratedCoordinateOf<model::FixedAngularMomentum>>); static_assert(std::same_as<decltype(std::declval<constFirst&>().specification<model::FixedTotalMass>()),constmodel::FixedTotalMass&>); static_assert(std::same_as<model::SpecificationsForRole<model::SpecificationRole::constitutive_law,First>,serif::utils::types::TypeList<SymbolicEOS>>); usingRole=model::SpecificationRole; static_assert(admitted_states<Role::constitutive_law>()==std::array{true,false,false,false}); static_assert(admitted_states<Role::boundary_condition>()==std::array{true,false,false,false}); static_assert(admitted_states<Role::invariant>()==std::array{false,true,true,false}); static_assert(admitted_states<Role::phase_condition>()==std::array{false,false,false,true}); static_assert(admitted_states<Role::gauge_choice>()==std::array{false,false,false,true}); static_assert(admitted_states<Role::rotation_law>()==std::array{true,false,false,false}); static_assert(!model::ModelSpecification<RoleChoice<static_cast<Role>(1000),model::GeneratedStateKind::none>>); static_assert(!model::ModelSpecification<RoleChoice<Role::constitutive_law,static_cast<model::GeneratedStateKind>(1000)>>); template<typenameEOS,typenameSurface> constevalboolindependent_constraint_choices() { usingDefinition=model::EquilibriumEquations<int,model::NoShapeForce,Surface>; usingMass=model::FixedTotalMass; usingMomentum=model::FixedAngularMomentum; returnmodel::StellarModelType<model::StellarModel<EOS,Definition,serif::utils::types::TypeList<>>>&& model::StellarModelType<model::StellarModel<EOS,Definition,serif::utils::types::TypeList<Mass>>>&& model::StellarModelType<model::StellarModel<EOS,Definition,serif::utils::types::TypeList<Momentum>>>&& model::StellarModelType<model::StellarModel<EOS,Definition,serif::utils::types::TypeList<Mass,Momentum>>>; } static_assert(independent_constraint_choices<SymbolicEOS,Boundary>()); static_assert(independent_constraint_choices<SymbolicEOS,OtherBoundary>()); static_assert(independent_constraint_choices<OtherSymbolicEOS,Boundary>()); static_assert(independent_constraint_choices<OtherSymbolicEOS,OtherBoundary>()); }