layout.cpp concepts array span type_traits utility vector serif/discretization/blocks/fields.hpp serif/discretization/blocks/vector_view.hpp serif/operators/linearized_system_view.hpp serif/solver/normalization/layout.hpp serif/solver/normalization/keys.hpp serif/backend/mfem/solver/preconditioner/computations/ordering.hpp serif/solver/preconditioner/default_preconditioners.hpp serif/utils/dependencies/dependencies.hpp src/compile_time_checks/serif/solver/preconditioner/layout.cpp serif/backend/mfem/operators/linearized_block.hpp serif/backend/mfem/solver/preconditioner/border.hpp serif/backend/mfem/solver/preconditioner/computations/ordering.hpp serif/backend/mfem/solver/preconditioner/coupling.hpp serif/backend/mfem/solver/preconditioner/inverse.hpp serif/dimensions/dimensions.hpp serif/dimensions/quantities.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/vector_view.hpp serif/discretization/domain/concepts.hpp serif/discretization/domain/physical_domains.hpp serif/discretization/domain/types.hpp serif/discretization/functional_space/space.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/operators/linearized_system_view.hpp serif/solver/normalization/keys.hpp serif/solver/normalization/layout.hpp serif/solver/preconditioner/contract.hpp serif/solver/preconditioner/default_preconditioners.hpp serif/solver/preconditioner/failure.hpp serif/solver/preconditioner/keys.hpp serif/solver/preconditioner/recipes/block.hpp serif/solver/preconditioner/recipes/bordered.hpp serif/solver/preconditioner/recipes/coupled.hpp serif/solver/preconditioner/strategies/coupling/order.hpp serif/solver/preconditioner/strategies/coupling/policies.hpp serif/solver/preconditioner/strategies/inverse/dense.hpp serif/solver/preconditioner/strategies/inverse/diagonal.hpp serif/solver/preconditioner/strategies/inverse/fixed_amg.hpp serif/solver/preconditioner/strategies/inverse/sparse_direct.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/dependencies.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/keys.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/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 compare concepts cstddef cstdint cstdio cstdlib exception expected format functional iostream limits magic_enum/magic_enum_all.hpp memory mfem/linalg/operator.hpp mfem/linalg/sparsemat.hpp nameof.hpp numeric ranges span stdexcept string string_view tuple type_traits unistd.h unordered_map utility variant vector version serif::solver::preconditioner::checks::ExtraField serif::solver::preconditioner::checks::ExtraValue serif::solver::preconditioner::checks::ExtraRow serif serif::solver serif::solver::preconditioner serif::solver::preconditioner::checks #include<concepts> #include<array> #include<span> #include<type_traits> #include<utility> #include<vector> #include"serif/discretization/blocks/fields.hpp" #include"serif/discretization/blocks/vector_view.hpp" #include"serif/operators/linearized_system_view.hpp" #include"serif/solver/normalization/layout.hpp" #include"serif/solver/normalization/keys.hpp" #include"serif/backend/mfem/solver/preconditioner/computations/ordering.hpp" #include"serif/solver/preconditioner/default_preconditioners.hpp" #include"serif/utils/dependencies/dependencies.hpp" namespaceserif::solver::preconditioner::checks { namespaceblocks=discretization::blocks; namespacedependencies=utils::dependencies; usingKind=blocks::RepresentedValueKind; usingMass=blocks::barotropic_constant::mass_normalization; usingReaction=blocks::frame_acceleration::component<0>; usingDensity=blocks::density::mass; usingKeys=dependencies::KeyList<Mass, Reaction>; usingLayout=blocks::SystemLayout<Keys, Keys>; usingState=blocks::StateView<Layout>; usingConstantState=blocks::StateView<Layout, const double>; usingPhysical=operators::PhysicalBlock<Mass,Reaction>; usingSources=decltype(dependencies::make_dependency_context(dependencies::own<Physical>(1))); usingSystem=operators::LinearizedSystemView<Layout,Sources>; template<typenameView,typenameKey> conceptReadsCoordinate=requires(constView&view) { view.templateget<Key>(); }; template<typenameView,typenameRow,typenameValue> conceptReadsBlock=requires(constView&view) { view.templateblock<Row,Value>(); }; template<typenameCandidate,typenameKey> conceptHasOffset=requires(constCandidate&layout) { layout.templateoffset<Kind::value,Key>(); }; static_assert(std::same_as<Mass::value,Reaction::value>); static_assert(Layout::index<Kind::value,Mass>()==0); static_assert(Layout::index<Kind::value,Reaction>()==1); static_assert(std::same_as<normalization::CoordinateLayout<Keys,Keys>,Layout>); static_assert(std::same_as<normalization::keys::Layout,keys::Layout>); static_assert(std::same_as<keys::Layout,blocks::keys::Layout>); usingReorderedLayout=blocks::SystemLayout<Keys,dependencies::KeyList<Reaction,Mass>>; constexprReorderedLayoutresolved_layout=blocks::make_system_layout<ReorderedLayout>([]<typenameCoordinate>(){ ifconstexpr(std::same_as<Coordinate,Mass>){ return3; }else{ return1; } }); static_assert(resolved_layout.state_sizes==std::array<std::size_t,2>{3,1}); static_assert(resolved_layout.residual_sizes==std::array<std::size_t,2>{1,3}); static_assert(blocks::SystemLayoutType<constLayout&>); static_assert(std::same_as<typenameblocks::SystemLayout<constKeys&,Keys>::Values,Keys>); static_assert(ReadsCoordinate<State, Mass>); static_assert(!ReadsCoordinate<State, Density>); static_assert(!ReadsCoordinate<State, Mass::value>); static_assert(HasOffset<Layout, Mass>); static_assert(!HasOffset<Layout, Density>); static_assert(std::same_as<decltype(std::declval<constState&>().get<Mass>()),std::span<double>>); static_assert(std::same_as<decltype(std::declval<constConstantState&>().get<Mass>()),std::span<constdouble>>); static_assert(std::constructible_from<State,constLayout&,std::span<double>>); static_assert(!std::constructible_from<State,Layout&&,std::span<double>>); static_assert(!std::constructible_from<State,constLayout&&,std::span<double>>); static_assert(!std::constructible_from<State,constLayout&,std::span<constdouble>>); static_assert(!std::constructible_from<ConstantState,constLayout&,std::vector<double>&&>); static_assert(!std::constructible_from<ConstantState,constLayout&,conststd::vector<double>&&>); static_assert(!std::constructible_from<ConstantState,constLayout&,std::array<double,2>&&>); static_assert(std::constructible_from<ConstantState,constLayout&,conststd::vector<double>&>); static_assert(std::constructible_from<ConstantState,constLayout&,std::span<constdouble,2>>); static_assert(std::constructible_from<blocks::StateView<constLayout&>,constLayout&,std::span<double>>); static_assert(!std::constructible_from<blocks::StateView<Layout&>,Layout&&,std::span<double>>); static_assert(ReadsBlock<System, Mass, Reaction>); static_assert(!ReadsBlock<System, Reaction, Mass>); static_assert(std::constructible_from<System,constLayout&,constSources&>); static_assert(!std::constructible_from<System,Layout&&,constSources&>); static_assert(!std::constructible_from<System,constLayout&,Sources&&>); static_assert(!std::constructible_from<System,constLayout&&,constSources&&>); static_assert(std::constructible_from<operators::LinearizedSystemView<constLayout&,constSources&>,constLayout&,constSources&>); }//namespaceserif::solver::preconditioner::checks namespaceserif::solver::preconditioner::checks{ usingPotential=blocks::gravity::potential; usingRotation=blocks::rotation::angular_velocity; usingShape=blocks::surface_deformation::coefficients; usingShapeRow=blocks::surface_deformation::shape_equilibrium; //Extrageneratedscalarsneednonewentryinthereciperegistry,evenwhenequationandvalueidentitiesdiffer. structExtraField:blocks::field{}; structExtraValue:blocks::term<ExtraField>,blocks::global_scalar{ usingSupport=discretization::domain::StellarDomains; }; structExtraRow:blocks::term<ExtraField>,blocks::global_scalar{ usingSupport=discretization::domain::StellarDomains; }; usingPrimalFields=dependencies::KeyList<Density,Potential>; usingPrimalFixedLayout=blocks::SystemLayout<PrimalFields,PrimalFields>; usingPrimalMovingLayout=blocks::SystemLayout<dependencies::KeyList<Potential,Shape,Mass,Density,Rotation>, dependencies::KeyList<Rotation,Mass,ShapeRow,Potential,Density>>; usingPrimalRecipe=decltype(make_primal_preconditioner(std::declval<constPrimalMovingLayout&>())); usingPrimalExtraLayout=blocks::SystemLayout<dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<ExtraValue>>, dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<ExtraRow>>>; usingPrimalExtraRecipe=decltype(make_primal_preconditioner(std::declval<constPrimalExtraLayout&>())); template<typenameCandidate> conceptHasPrimalPreconditioner=requires(constCandidate&layout){ make_primal_preconditioner(layout); }; static_assert(HasPrimalPreconditioner<PrimalFixedLayout>); static_assert(HasPrimalPreconditioner<const PrimalMovingLayout&>); static_assert(HasPrimalPreconditioner<PrimalExtraLayout>); static_assert(!HasPrimalPreconditioner<int>); static_assert(!HasPrimalPreconditioner<blocks::SystemLayout<dependencies::KeyList<Density>,dependencies::KeyList<Density>>>); static_assert(!HasPrimalPreconditioner<blocks::SystemLayout< dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<Shape>>,PrimalFields>>); static_assert(!HasPrimalPreconditioner<blocks::SystemLayout< dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<Mass>>,PrimalFields>>); static_assert(!HasPrimalPreconditioner<blocks::SystemLayout< dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<blocks::displacement::vector>>, dependencies::CombinedKeyList<PrimalFields,dependencies::KeyList<blocks::displacement::vector>>>>); static_assert(std::same_as<typenamePrimalRecipe::Values,dependencies::KeyList<Density,Potential,Shape,Mass,Rotation>>); static_assert(std::same_as<typenamePrimalRecipe::Rows,dependencies::KeyList<Density,Potential,Rotation,Mass,ShapeRow>>); static_assert(std::same_as<typenamePrimalExtraRecipe::Values,dependencies::KeyList<Density,Potential,ExtraValue>>); static_assert(std::same_as<typenamePrimalExtraRecipe::Rows,dependencies::KeyList<Density,Potential,ExtraRow>>); static_assert(std::same_as<decltype(std::declval<PrimalRecipe>().fields.coupling),strategies::coupling::SecondThenFirst>); static_assert(std::same_as<decltype(std::declval<PrimalRecipe>().fields.first.inverse),strategies::inverse::Diagonal>); static_assert(std::same_as<decltype(std::declval<PrimalRecipe>().fields.second.inverse),strategies::inverse::FixedAMG>); }