state.cpp concepts span type_traits utility vector serif/backend/mfem/model/equilibrium.hpp serif/model/state.hpp serif::model::checks::Binding serif::model::checks::MovingPlan serif::model::checks::MovingPlan::Surface serif::model::checks::FixedPlan serif::model::checks::Bound serif serif::model serif::model::checks #include<concepts> #include<span> #include<type_traits> #include<utility> #include<vector> #include"serif/backend/mfem/model/equilibrium.hpp" #include"serif/model/state.hpp" namespaceserif::model::checks{ namespaceblocks=discretization::blocks; namespacedependencies=utils::dependencies; namespaceexecution=backend::mfem; usingDensity=blocks::density::mass; usingRotation=blocks::rotation::angular_velocity; usingShape=blocks::surface_deformation::coefficients; usingShapeRow=blocks::surface_deformation::shape_equilibrium; usingValues=dependencies::KeyList<Density,Shape>; usingRows=dependencies::KeyList<ShapeRow,Density>; usingLayout=blocks::SystemLayout<Values,Rows>; usingState=StellarState<Layout>; usingEmptyInputs=dependencies::DependencyContext<>; template<typenameOwner,typenameTerm> conceptReadsField=requires(Owner&&state){ std::forward<Owner>(state).templateget<Term>(); }; template<typenameOwner> conceptReadsValues=requires(Owner&&state){ std::forward<Owner>(state).values(); }; template<typenameOwner> conceptReadsLayout=requires(Owner&&state){ std::forward<Owner>(state).layout(); }; static_assert(std::copyable<State>); static_assert(std::same_as<typenameStellarState<constLayout&>::Layout,Layout>); static_assert(std::constructible_from<StellarState<constLayout&>,Layout>); static_assert(std::same_as<decltype(StellarState(std::declval<constLayout&>())),State>); static_assert(std::same_as<decltype(StellarState(std::declval<Layout>(),std::declval<std::vector<double>>())),State>); static_assert(std::same_as<decltype(std::declval<State&>().get<Density>()),std::span<double>>); static_assert(std::same_as<decltype(std::declval<constState&>().get<Density>()),std::span<constdouble>>); static_assert(std::same_as<decltype(std::declval<State&>().values()),std::span<double>>); static_assert(std::same_as<decltype(std::declval<constState&>().values()),std::span<constdouble>>); static_assert(std::same_as<decltype(std::declval<State&>().layout()),constLayout&>); static_assert(ReadsField<State&, Density>&&ReadsField<const State&, Shape>); static_assert(!ReadsField<State&, ShapeRow>&&!ReadsField<State&, Rotation>); static_assert(!ReadsField<State, Density>&&!ReadsField<const State, Density>); static_assert(ReadsValues<State&>&&ReadsValues<const State&>); static_assert(!ReadsValues<State>&&!ReadsValues<const State>); static_assert(ReadsLayout<State&>&&ReadsLayout<const State&>); static_assert(!ReadsLayout<State>&&!ReadsLayout<const State>); template<typenameTermT> structBinding{ usingTerm=TermT; }; template<typenameKey,typenameTerm=Key> usingCoefficientSource=decltype(dependencies::own<Key>(std::declval<operators::backend::mfem::CoefficientView<Binding<Term>>>())); usingRotationInputs=dependencies::DependencyContext<CoefficientSource<Rotation>>; usingWrongIdentity=dependencies::DependencyContext<CoefficientSource<Rotation,Density>>; usingWrongValue=decltype(dependencies::make_dependency_context(dependencies::own<Rotation>(1.0))); usingOverlap=dependencies::DependencyContext<CoefficientSource<Density>,CoefficientSource<Rotation>>; usingShapeOverlap=dependencies::DependencyContext<CoefficientSource<Shape>,CoefficientSource<Rotation>>; usingCompleteFields=dependencies::DependencyContext<CoefficientSource<Density>,CoefficientSource<Rotation>>; structMovingPlan{ usingValues=checks::Values; usingCoefficients=dependencies::KeyList<Density,Rotation>; usingLayout=checks::Layout; structSurface{ usingFormulation=void; }; staticconstexprboolhas_shape=true; }; structFixedPlan:MovingPlan{ usingValues=dependencies::KeyList<Density>; usingLayout=blocks::SystemLayout<Values,Values>; staticconstexprboolhas_shape=false; }; template<typenamePlanT> structBound{ usingPlan=PlanT; }; //Aconstantgraphchecksoverloadparticipationwithoutconstructingfinite-elementresources. usingGraph=decltype(dependencies::make_computation_graph( dependencies::make_computation<keys::PhysicalSystem,dependencies::InputList<>>([](){ return0; }))); usingMovingEvaluator=execution::EquilibriumEvaluator<Bound<MovingPlan>,Graph,EmptyInputs>; usingFixedEvaluator=execution::EquilibriumEvaluator<Bound<FixedPlan>,Graph,EmptyInputs>; usingPreparedGraph=decltype(dependencies::make_computation_graph( dependencies::make_computation<keys::PhysicalSystem,dependencies::InputList<>>([](){ return0; }),dependencies::make_computation<preconditioning::PreparedSystem,dependencies::InputList<keys::PhysicalSystem>>([](intvalue){ returnvalue; }))); usingMovingPreparedEvaluator=execution::EquilibriumEvaluator<Bound<MovingPlan>,PreparedGraph,EmptyInputs>; usingFixedPreparedEvaluator=execution::EquilibriumEvaluator<Bound<FixedPlan>,PreparedGraph,EmptyInputs>; usingFixedState=StellarState<FixedPlan::Layout>; usingOtherState=StellarState<blocks::SystemLayout<dependencies::KeyList<Shape, Density>,Rows>>; template<typenameEvaluator,typename...Arguments> conceptCanEvaluate=requires(Evaluator&evaluator,constArguments&...arguments){ evaluator.evaluate(arguments...); }; template<typenameEvaluator,typename...Arguments> conceptCanPrepareLinearSystem=requires(Evaluator&evaluator,constArguments&...arguments){ evaluator.prepare_linear_system(arguments...); }; static_assert(execution::detail::PrescribedInputsFor<MovingPlan,RotationInputs>); static_assert(!execution::detail::PrescribedInputsFor<MovingPlan,EmptyInputs>); static_assert(!execution::detail::PrescribedInputsFor<MovingPlan,WrongIdentity>); static_assert(!execution::detail::PrescribedInputsFor<MovingPlan,WrongValue>); static_assert(!execution::detail::PrescribedInputsFor<MovingPlan,Overlap>); static_assert(!execution::detail::PrescribedInputsFor<MovingPlan,ShapeOverlap>); static_assert(CanEvaluate<MovingEvaluator, State, RotationInputs>); static_assert(!CanEvaluate<MovingEvaluator, State>); static_assert(!CanEvaluate<MovingEvaluator, State, EmptyInputs>); static_assert(!CanEvaluate<MovingEvaluator, State, WrongIdentity>); static_assert(!CanEvaluate<MovingEvaluator, State, WrongValue>); static_assert(!CanEvaluate<MovingEvaluator, State, Overlap>); static_assert(!CanEvaluate<MovingEvaluator, OtherState, RotationInputs>); static_assert(!CanEvaluate<MovingEvaluator, State, dependencies::PreparationMode>); static_assert(CanEvaluate<MovingEvaluator, CompleteFields, std::span<const double>>); static_assert(!CanEvaluate<MovingEvaluator, RotationInputs, std::span<const double>>); static_assert(CanEvaluate<FixedEvaluator, FixedState, ::mfem::Vector, RotationInputs>); static_assert(!CanEvaluate<FixedEvaluator, FixedState, ::mfem::Vector>); static_assert(!CanEvaluate<FixedEvaluator, FixedState, ::mfem::Vector, Overlap>); static_assert(!CanEvaluate<FixedEvaluator, State, ::mfem::Vector, RotationInputs>); static_assert(!CanPrepareLinearSystem<MovingEvaluator, State, RotationInputs>); static_assert(!CanPrepareLinearSystem<FixedEvaluator, FixedState, ::mfem::Vector, RotationInputs>); static_assert(CanPrepareLinearSystem<MovingPreparedEvaluator, State, RotationInputs>); static_assert(CanPrepareLinearSystem<MovingPreparedEvaluator, State, RotationInputs, dependencies::PreparationMode>); static_assert(CanPrepareLinearSystem<MovingPreparedEvaluator, CompleteFields, std::span<const double>>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, State>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, State, EmptyInputs>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, State, WrongIdentity>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, State, WrongValue>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, State, Overlap>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, OtherState, RotationInputs>); static_assert(!CanPrepareLinearSystem<MovingPreparedEvaluator, RotationInputs, std::span<const double>>); static_assert(CanPrepareLinearSystem<FixedPreparedEvaluator, FixedState, ::mfem::Vector, RotationInputs>); static_assert(!CanPrepareLinearSystem<FixedPreparedEvaluator, FixedState, ::mfem::Vector>); static_assert(!CanPrepareLinearSystem<FixedPreparedEvaluator, State, ::mfem::Vector, RotationInputs>); }