plan.cpp array concepts cstddef expected string tuple type_traits utility vector serif/solver/normalization/computations.hpp serif/solver/normalization/physical_coordinates.hpp serif/equations/angular_momentum.hpp serif/equations/mass_normalization.hpp serif/equations/primal_gravity.hpp serif/eos/models/polytropic.hpp serif/utils/dependencies/computation_cache.hpp src/compile_time_checks/serif/solver/normalization/plan.cpp 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/keys.hpp serif/discretization/blocks/system_layout.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/models/polytropic.hpp serif/eos/relations/catalog.hpp serif/eos/relations/relations.hpp serif/equations/angular_momentum.hpp serif/equations/contributions.hpp serif/equations/mass_normalization.hpp serif/equations/point.hpp serif/equations/primal_gravity.hpp serif/equations/rigid_rotation.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/solver/normalization/computations.hpp serif/solver/normalization/detail/factor_computations.hpp serif/solver/normalization/detail/packing.hpp serif/solver/normalization/detail/validation.hpp serif/solver/normalization/diagonal.hpp serif/solver/normalization/dimensionless.hpp serif/solver/normalization/keys.hpp serif/solver/normalization/layout.hpp serif/solver/normalization/metrics.hpp serif/solver/normalization/physical_coordinates.hpp serif/solver/normalization/plan.hpp serif/solver/normalization/point_rows.hpp serif/solver/normalization/scales.hpp serif/utils/dependencies/binding.hpp serif/utils/dependencies/computation.hpp serif/utils/dependencies/computation_cache.hpp serif/utils/dependencies/computation_graph.hpp serif/utils/dependencies/dependency_context.hpp serif/utils/dependencies/detail/cache_storage.hpp serif/utils/dependencies/detail/cache_traits.hpp serif/utils/dependencies/detail/graph.hpp serif/utils/dependencies/detail/result.hpp serif/utils/dependencies/detail/schema.hpp serif/utils/dependencies/detail/type_lists.hpp serif/utils/dependencies/key_list.hpp serif/utils/dependencies/key_list_operations.hpp serif/utils/dependencies/observers.hpp serif/utils/dependencies/preparation.hpp serif/utils/dependencies/resource.hpp serif/utils/dependencies/snapshot.hpp serif/utils/error/codes.hpp serif/utils/error/errors.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/types/strings.hpp serif/utils/types/type_list.hpp algorithm array cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional iostream magic_enum/magic_enum_all.hpp memory nameof.hpp numeric span stdexcept string string_view tuple type_traits unistd.h unordered_map utility variant vector version serif::solver::normalization::checks::FirstValue serif::solver::normalization::checks::SecondValue serif::solver::normalization::checks::FirstResidual serif::solver::normalization::checks::SecondResidual serif::solver::normalization::checks::ForeignCoordinate serif::solver::normalization::checks::PressureRow serif::solver::normalization::checks::MassRow serif::solver::normalization::checks::CentralRow serif::solver::normalization::checks::SelectedSurfaceRows serif::solver::normalization::checks::CustomDensityMetric serif::solver::normalization::checks::SharedFieldMetric serif::solver::normalization::checks::MalformedMetric serif::solver::normalization::checks::MissingMetricMetadata serif::solver::normalization::checks::DuplicateMetricCoordinates serif::solver::normalization::checks::PretendRieszMethod serif::solver::normalization::checks::MoveOnlyPrescription serif::solver::normalization::checks::PreparedPrescription serif::solver::normalization::checks::DerivedPrescription serif::solver::normalization::checks::ConvertiblePrescription serif::solver::normalization::checks::WrongPreparationResult serif::solver::normalization::checks::BorrowedPreparationResult serif::solver::normalization::checks::StateOnlyPrescription serif::solver::normalization::checks::AliasesOnlyLayout serif::solver::normalization::checks::TemperatureCoordinate serif::solver::normalization::checks::TemperatureMetric serif::solver::normalization::checks::TemperatureScales serif::solver::normalization::checks::UntypedTemperatureScales serif serif::solver serif::solver::normalization serif::solver::normalization::checks #include<array> #include<concepts> #include<cstddef> #include<expected> #include<string> #include<tuple> #include<type_traits> #include<utility> #include<vector> #include"serif/solver/normalization/computations.hpp" #include"serif/solver/normalization/physical_coordinates.hpp" #include"serif/equations/angular_momentum.hpp" #include"serif/equations/mass_normalization.hpp" #include"serif/equations/primal_gravity.hpp" #include"serif/eos/models/polytropic.hpp" #include"serif/utils/dependencies/computation_cache.hpp" namespaceserif::solver::normalization::checks { namespaceblocks=discretization::blocks; namespacedependencies=utils::dependencies; usingdependencies::Binding; usingdependencies::Bindings; usingdependencies::KeyList; usingDensity=blocks::density::mass; usingPotential=blocks::gravity::potential; usingDisplacement=blocks::displacement::vector; usingMassConstant=blocks::barotropic_constant::mass_normalization; usingAngularVelocity=blocks::rotation::angular_velocity; usingCentralBorder=blocks::frame_acceleration::component<0>; usingSurfaceCoefficients=blocks::surface_deformation::coefficients; usingSurfaceEquilibrium=blocks::surface_deformation::shape_equilibrium; usingSurfaceMetric=geometry::deformation::keys::SurfaceMetric; structFirstValue { }; structSecondValue { }; structFirstResidual { }; structSecondResidual { }; structForeignCoordinate { }; usingValues=KeyList<FirstValue,SecondValue>; usingResiduals=KeyList<FirstResidual,SecondResidual>; usingValueRules=Bindings<Binding<FirstValue,IdentityCoordinate>,Binding<SecondValue,IdentityCoordinate>>; usingResidualRules=Bindings<Binding<FirstResidual,IdentityCoordinate>,Binding<SecondResidual,IdentityCoordinate>>; usingCompletePlan=NormalizationPlan<ValueRules, ResidualRules>; usingReorderedPlan=NormalizationPlan< Bindings<Binding<SecondValue,IdentityCoordinate>,Binding<FirstValue,IdentityCoordinate>>, Bindings<Binding<SecondResidual,IdentityCoordinate>,Binding<FirstResidual,IdentityCoordinate>>>; //MeanFieldplan.cpp:bothrolesproveexactownershipindependentlyofdeclarationorder. static_assert(NormalizationPlanType<CompletePlan>); static_assert(NormalizationPlanType<const CompletePlan&>); static_assert(CompleteNormalizationFor<CompletePlan, Values, Residuals>); static_assert(CompleteNormalizationFor<ReorderedPlan, Values, Residuals>); static_assert(CompleteNormalizationFor<const ReorderedPlan&, const Values&, volatile Residuals&&>); static_assert(CompleteNormalizationFor<CompletePlan, KeyList<SecondValue, FirstValue>,KeyList<SecondResidual,FirstResidual>>); static_assert(CompleteNormalizationFor<NormalizationPlan<Bindings<>,Bindings<>>,KeyList<>,KeyList<>>); static_assert(CompleteNormalizationFor<NormalizationPlan<Bindings<Binding<Density, IdentityCoordinate>>,Bindings<Binding<Density,IdentityCoordinate>>>,KeyList<Density>,KeyList<Density>>); usingMissingValue=NormalizationPlan<Bindings<Binding<FirstValue, IdentityCoordinate>>,ResidualRules>; usingMissingResidual=NormalizationPlan<ValueRules, Bindings<Binding<FirstResidual, IdentityCoordinate>>>; usingDuplicateValue=NormalizationPlan<Bindings<Binding<FirstValue, IdentityCoordinate>,Binding<FirstValue,IdentityCoordinate>>,ResidualRules>; usingDuplicateResidual=NormalizationPlan<ValueRules, Bindings<Binding<FirstResidual, IdentityCoordinate>,Binding<FirstResidual,IdentityCoordinate>>>; usingForeignValue=NormalizationPlan<Bindings<Binding<FirstValue, IdentityCoordinate>,Binding<ForeignCoordinate,IdentityCoordinate>>,ResidualRules>; usingForeignResidual=NormalizationPlan<ValueRules, Bindings<Binding<FirstResidual, IdentityCoordinate>,Binding<ForeignCoordinate,IdentityCoordinate>>>; static_assert(!CompleteNormalizationFor<MissingValue, Values, Residuals>); static_assert(!CompleteNormalizationFor<MissingResidual, Values, Residuals>); static_assert(!NormalizationPlanType<DuplicateValue>); static_assert(!NormalizationPlanType<DuplicateResidual>); static_assert(!CompleteNormalizationFor<ForeignValue, Values, Residuals>); static_assert(!CompleteNormalizationFor<ForeignResidual, Values, Residuals>); static_assert(!CompleteNormalizationFor<CompletePlan, KeyList<FirstValue, FirstValue>,Residuals>); static_assert(!CompleteNormalizationFor<CompletePlan, Values, KeyList<FirstResidual, FirstResidual>>); static_assert(!CompleteNormalizationFor<CompletePlan, Residuals, Values>); static_assert(!CompleteNormalizationFor<CompletePlan, int, Residuals>); static_assert(!CompleteNormalizationFor<const int&, Values, Residuals>); static_assert(!NormalizationPlanType<NormalizationPlan<int, ResidualRules>>); static_assert(!NormalizationPlanType<NormalizationPlan<ValueRules, void>>); usingLayout=CoordinateLayout<const Values&, volatile Residuals&&>; static_assert(std::same_as<Layout::Values,Values>); static_assert(std::same_as<Layout::Residuals,Residuals>); static_assert(std::same_as<decltype(Layout::state_sizes),std::array<std::size_t,2>>); static_assert(std::same_as<decltype(Layout::residual_sizes),std::array<std::size_t,2>>); static_assert(std::is_aggregate_v<Layout>); template<typenameStateKeys,typenameResidualKeys> conceptCanDeclareLayout=requires { typenameCoordinateLayout<StateKeys, ResidualKeys>; }; static_assert(!CanDeclareLayout<int, Residuals>); static_assert(!CanDeclareLayout<Values, int>); static_assert(!CanDeclareLayout<KeyList<FirstValue, FirstValue>,Residuals>); usingDensityRiesz=PhysicalRieszCoordinate<dimensions::MassDensity, ReferenceVolumeMetric<Density>>; usingDisplacementRiesz=PhysicalRieszCoordinate<dimensions::Length, ReferenceVolumeMetric<Displacement>>; usingPhysicalValues=NormalizationPlan<Bindings<Binding<Density, DensityRiesz>,Binding<Displacement,DisplacementRiesz>>,Bindings<>>; static_assert(CompleteNormalizationFor<PhysicalValues, KeyList<Displacement, Density>,KeyList<>>); static_assert(!MetricFor<ReferenceVolumeMetric<Displacement>,Density>); static_assert(!MetricFor<ReferenceVolumeMetric<Density>,Potential>); static_assert(!MetricFor<UnitMetric, Density>); static_assert(!MetricFor<int, Density>); static_assert(!MetricFor<UnitMetric, int>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, PhysicalRieszCoordinate<dimensions::Pressure, ReferenceVolumeMetric<Density>>>>,Bindings<>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, PhysicalRieszCoordinate<dimensions::MassDensity, ReferenceVolumeMetric<Displacement>>>>,Bindings<>>>); structPressureRow { usingTest=Density; usingQuantity=dimensions::MassDensity; usingResidualQuantity=dimensions::Pressure; }; structMassRow { usingTest=MassConstant; usingResidualQuantity=dimensions::Mass; }; structCentralRow { usingTest=Density; usingBorder=CentralBorder; usingResidualQuantity=dimensions::MassDensity; }; //Rowphysicsoverridesthesampledfield'squantity;acentralpointrowusesitsscalarbordermetric. usingPressureRiesz=PhysicalRieszCoordinate<dimensions::Pressure, ReferenceVolumeMetric<Density>>; usingPressurePlan=NormalizationPlan<Bindings<>,Bindings<Binding<PressureRow,PressureRiesz>>>; static_assert(CompleteNormalizationFor<PressurePlan, KeyList<>,KeyList<PressureRow>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<PressureRow,DensityRiesz>>>>); static_assert(NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<Density,PressureRiesz>>>>); static_assert(MetricFor<UnitMetric, MassRow>); static_assert(MetricFor<UnitMetric, CentralRow>); static_assert(!MetricFor<ReferenceVolumeMetric<Density>,CentralRow>); static_assert(NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<MassRow,PhysicalRieszCoordinate<dimensions::Mass,UnitMetric>>>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<MassRow,PhysicalRieszCoordinate<dimensions::SpecificEnthalpy,UnitMetric>>>>>); structSelectedSurfaceRows { }; usingPotentialRiesz=PhysicalRieszCoordinate<dimensions::GravitationalPotential, ReferenceVolumeMetric<Potential>>; usingHybridResidual=WithPointRows<PotentialRiesz, dimensions::Pressure, SelectedSurfaceRows>; static_assert(NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<Potential,HybridResidual>>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Potential, HybridResidual>>,Bindings<>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<>,Bindings<Binding<Potential,WithPointRows<IdentityCoordinate,dimensions::Pressure,SelectedSurfaceRows>>>>>); //Inheritedscalarblockaliasescoincide;physicalcoordinateidentitiesmustneverdoso. static_assert(std::same_as<MassConstant::value,AngularVelocity::value>); static_assert(std::same_as<MassConstant::residual,CentralBorder::residual>); static_assert(!std::same_as<MassConstant,AngularVelocity>); usingScalarValues=KeyList<MassConstant,AngularVelocity,CentralBorder>; usingScalarPlan=NormalizationPlan<Bindings< Binding<AngularVelocity,PhysicalRieszCoordinate<dimensions::AngularVelocity,UnitMetric>>, Binding<CentralBorder,PhysicalRieszCoordinate<dimensions::Acceleration,UnitMetric>>, Binding<MassConstant,PhysicalRieszCoordinate<dimensions::GravitationalPotential,UnitMetric>>>,Bindings<>>; static_assert(CompleteNormalizationFor<ScalarPlan, ScalarValues, KeyList<>>); static_assert(!CompleteNormalizationFor<ScalarPlan, KeyList<MassConstant::value>,KeyList<>>); static_assert(!MetricFor<UnitMetric, MassConstant::value>); structCustomDensityMetric { usingCoordinates=KeyList<Density>; }; structSharedFieldMetric { usingCoordinates=KeyList<Density,Potential>; }; structMalformedMetric { usingCoordinates=int; }; structMissingMetricMetadata { }; structDuplicateMetricCoordinates { usingCoordinates=KeyList<Density,Density>; }; structPretendRieszMethod { usingQuantity=dimensions::MassDensity; usingMetric=CustomDensityMetric; }; static_assert(MetricFor<CustomDensityMetric, Density>); static_assert(MetricFor<CustomDensityMetric, PressureRow>); static_assert(!MetricFor<CustomDensityMetric, Potential>); static_assert(MetricFor<SharedFieldMetric, Density>); static_assert(MetricFor<SharedFieldMetric, Potential>); static_assert(!MetricFor<MalformedMetric, Density>); static_assert(!MetricFor<MissingMetricMetadata, Density>); static_assert(!MetricFor<DuplicateMetricCoordinates, Density>); static_assert(NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, PhysicalRieszCoordinate<dimensions::MassDensity, CustomDensityMetric>>>,Bindings<>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, PretendRieszMethod>>,Bindings<>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, int>>,Bindings<>>>); static_assert(!NormalizationPlanType<NormalizationPlan<Bindings<Binding<Density, const IdentityCoordinate&>>,Bindings<>>>); //Nativeshapecoordinatessharedeformation'stracemetric,independentlyofthevolumedisplacementbasis. static_assert(MetricFor<SurfaceMetric, SurfaceCoefficients>); static_assert(MetricFor<SurfaceMetric, SurfaceEquilibrium>); static_assert(!MetricFor<SurfaceMetric, blocks::displacement::vector>); static_assert(!MetricFor<UnitMetric, SurfaceCoefficients>); usingSurfacePlan=NormalizationPlan< Bindings<Binding<SurfaceCoefficients,PhysicalRieszCoordinate<dimensions::Length,SurfaceMetric>>>, Bindings<Binding<SurfaceEquilibrium,PhysicalRieszCoordinate<dimensions::Force,SurfaceMetric>>>>; static_assert(CompleteNormalizationFor<SurfacePlan, KeyList<SurfaceCoefficients>,KeyList<SurfaceEquilibrium>>); structMoveOnlyPrescriptionfinal:NormalizationPrescriptionTag { MoveOnlyPrescription()=default; MoveOnlyPrescription(constMoveOnlyPrescription&)=delete; MoveOnlyPrescription&operator=(constMoveOnlyPrescription&)=delete; MoveOnlyPrescription(MoveOnlyPrescription&&)=default; MoveOnlyPrescription&operator=(MoveOnlyPrescription&&)=default; }; template<typenameCandidate> conceptCanDeclareRuntimeMethod=requires { typenameRuntimePreparedCoordinate<Candidate>; }; usingCustomMethod=RuntimePreparedCoordinate<const MoveOnlyPrescription&>; usingCustomPlan=NormalizationPlan<Bindings<Binding<Density, CustomMethod>>,Bindings<Binding<PressureRow,CustomMethod>>>; static_assert(!std::copy_constructible<MoveOnlyPrescription>); static_assert(std::move_constructible<MoveOnlyPrescription>); static_assert(NormalizationPrescription<const MoveOnlyPrescription&>); static_assert(std::same_as<CustomMethod::Prescription,MoveOnlyPrescription>); static_assert(CompleteNormalizationFor<CustomPlan, KeyList<Density>,KeyList<PressureRow>>); static_assert(!CanDeclareRuntimeMethod<int>); static_assert(!NormalizationPrescription<PretendRieszMethod>); structPreparedPrescription:NormalizationPrescriptionTag { template<blocks::RepresentedValueKindKind,typenameCoordinate> [[nodiscard]]std::expected<std::vector<double>,std::string>prepare_factors(keys::Factors<Kind, Coordinate>,std::size_tsize)const { returnstd::vector<double>(size,0.5); } [[nodiscard]]booloperator==(constPreparedPrescription&)constnoexcept { returntrue; } }; structDerivedPrescriptionfinal:PreparedPrescription { }; structConvertiblePrescriptionfinal { PreparedPrescriptionprescription; operatorconstPreparedPrescription&()constnoexcept { returnprescription; } [[nodiscard]]booloperator==(constConvertiblePrescription&)const=default; }; structWrongPreparationResultfinal:NormalizationPrescriptionTag { template<blocks::RepresentedValueKindKind,typenameCoordinate> [[nodiscard]]intprepare_factors(keys::Factors<Kind, Coordinate>,std::size_t)const; }; structBorrowedPreparationResultfinal:NormalizationPrescriptionTag { template<blocks::RepresentedValueKindKind,typenameCoordinate> [[nodiscard]]conststd::expected<std::vector<double>,std::string>&prepare_factors(keys::Factors<Kind, Coordinate>,std::size_t)const; }; structStateOnlyPrescriptionfinal:NormalizationPrescriptionTag { [[nodiscard]]std::expected<std::vector<double>,std::string>prepare_factors(keys::Factors<blocks::RepresentedValueKind::value, Density>,std::size_t)const; }; template<typenamePolicy> usingPolicyPlan=NormalizationPlan< Bindings<Binding<Density,RuntimePreparedCoordinate<Policy>>>, Bindings<Binding<PressureRow,RuntimePreparedCoordinate<Policy>>>>; usingPolicyLayout=CoordinateLayout<KeyList<Density>,KeyList<PressureRow>>; static_assert(NormalizationPreparable<CompletePlan, Layout>); static_assert(NormalizationPreparable<const CompletePlan&, const Layout&>); static_assert(NormalizationPreparable<PolicyPlan<PreparedPrescription>,PolicyLayout>); static_assert(!NormalizationPreparable<PolicyPlan<MoveOnlyPrescription>,PolicyLayout>); static_assert(!NormalizationPreparable<PolicyPlan<WrongPreparationResult>,PolicyLayout>); static_assert(!NormalizationPreparable<PolicyPlan<BorrowedPreparationResult>,PolicyLayout>); static_assert(!NormalizationPreparable<PolicyPlan<StateOnlyPrescription>,PolicyLayout>); static_assert(!NormalizationPreparable<int, PolicyLayout>); static_assert(!NormalizationPreparable<CompletePlan, int>); static_assert(!NormalizationPreparable<MissingValue, Layout>); static_assert(!NormalizationPreparable<PhysicalValues, CoordinateLayout<KeyList<Density, Displacement>,KeyList<>>,int>); structAliasesOnlyLayout { usingValues=checks::Values; usingResiduals=checks::Residuals; }; static_assert(!NormalizationPreparable<CompletePlan, AliasesOnlyLayout>); usingQualifiedPolicyComputation=decltype(detail::coordinate_computation<blocks::RepresentedValueKind::value, Density, PolicyLayout, StellarReferenceScales>(RuntimePreparedCoordinate<const PreparedPrescription&>{})); static_assert(std::same_as<QualifiedPolicyComputation::Inputs,KeyList<keys::Layout,keys::Prescription<PreparedPrescription>>>); //Thegeneratedrulesreadresidualphysicsfromequations,neverfromthescalarunknowntheyclose. static_assert(std::same_as<PhysicalValueRule<AngularVelocity>::Target,PhysicalRieszCoordinate<dimensions::AngularVelocity, UnitMetric>>); static_assert(std::same_as<PhysicalResidualRule<equations::AngularMomentumConstraint>::Target,PhysicalRieszCoordinate<dimensions::AngularMomentum, UnitMetric>>); static_assert(std::same_as<PhysicalResidualRule<equations::MassNormalization>::Target,PhysicalRieszCoordinate<dimensions::Mass, UnitMetric>>); static_assert(std::same_as<PhysicalResidualRule<equations::PrimalPoissonBalance>::Target,PhysicalRieszCoordinate<dimensions::InverseTimeSquared, ReferenceVolumeMetric<blocks::gravity::potential>>>); structTemperatureCoordinate { usingQuantity=dimensions::Temperature; }; structTemperatureMetric { usingCoordinates=KeyList<TemperatureCoordinate>; }; structTemperatureScales { }; [[nodiscard]]dimensions::QuantityValue<dimensions::Temperature>characteristic_scale(constTemperatureScales&,dimensions::Temperature); structUntypedTemperatureScales { }; [[nodiscard]]doublecharacteristic_scale(constUntypedTemperatureScales&,dimensions::Temperature); usingTemperaturePlan=NormalizationPlan<Bindings<Binding<TemperatureCoordinate, PhysicalRieszCoordinate<dimensions::Temperature, TemperatureMetric>>>,Bindings<>>; usingTemperatureLayout=CoordinateLayout<KeyList<TemperatureCoordinate>,KeyList<>>; static_assert(NormalizationPlanType<TemperaturePlan>); static_assert(!NormalizationPreparable<TemperaturePlan, TemperatureLayout>); static_assert(NormalizationPreparable<TemperaturePlan, TemperatureLayout, TemperatureScales>); static_assert(NormalizationPreparable<const TemperaturePlan&, const TemperatureLayout&, const TemperatureScales&>); static_assert(!NormalizationPreparable<TemperaturePlan, TemperatureLayout, UntypedTemperatureScales>); template<typename...Computations> autograph_type(std::tuple<Computations...>)->decltype(dependencies::make_computation_graph(std::declval<Computations>()...)); template<typenameKey,typenameValue> usingOwnedSource=decltype(dependencies::own<Key>(std::declval<Value>())); usingMetricLayout=CoordinateLayout<KeyList<Density, Displacement>,KeyList<>>; usingMetricComputations=decltype(make_normalization_computations<const PhysicalValues&>(std::declval<constMetricLayout&>())); usingMetricGraph=decltype(graph_type(std::declval<MetricComputations>())); usingLayoutSource=OwnedSource<keys::Layout, MetricLayout>; usingScaleSource=OwnedSource<keys::Scales, StellarReferenceScales>; usingDensityMetricSource=OwnedSource<ReferenceVolumeMetric<Density>,std::vector<double>>; usingDisplacementMetricSource=OwnedSource<ReferenceVolumeMetric<Displacement>,std::vector<double>>; usingCompleteMetricContext=dependencies::DependencyContext<LayoutSource,ScaleSource,DensityMetricSource,DisplacementMetricSource>; usingMissingMetricContext=dependencies::DependencyContext<LayoutSource,ScaleSource,DensityMetricSource>; usingWrongMetricContext=dependencies::DependencyContext<LayoutSource,ScaleSource,DensityMetricSource,OwnedSource<ReferenceVolumeMetric<Displacement>,std::vector<int>>>; static_assert(dependencies::CanPrepare<MetricGraph,CompleteMetricContext,std::string>); static_assert(!dependencies::CanPrepare<MetricGraph,MissingMetricContext,std::string>); static_assert(!dependencies::CanPrepare<MetricGraph,WrongMetricContext,std::string>); static_assert(!dependencies::CanPrepare<MetricGraph,CompleteMetricContext,int>); usingPolicyComputations=decltype(make_normalization_computations<PolicyPlan<PreparedPrescription>>(std::declval<constPolicyLayout&>())); usingPolicyGraph=decltype(graph_type(std::declval<PolicyComputations>())); template<typenameSuppliedPrescription> usingPolicyContext=dependencies::DependencyContext<OwnedSource<keys::Layout,PolicyLayout>,OwnedSource<keys::Prescription<PreparedPrescription>,SuppliedPrescription>>; static_assert(std::equality_comparable<DerivedPrescription>); static_assert(std::equality_comparable<ConvertiblePrescription>); static_assert(dependencies::CanPrepare<PolicyGraph,PolicyContext<PreparedPrescription>,std::string>); static_assert(!dependencies::CanPrepare<PolicyGraph,PolicyContext<DerivedPrescription>,std::string>); static_assert(!dependencies::CanPrepare<PolicyGraph,PolicyContext<ConvertiblePrescription>,std::string>); } namespaceserif::solver::normalization::checks{ static_assert(DimensionlessMetricGeometry<geometry::deformation::keys::SurfaceMetric>::value==ReferenceGeometry::surface); }