feat(libmeanfield): variadic refactor

also added normaliztion operator

libmeanfield/interface/preconditioning/stellar_structure.cppm

@@ -14,6 +14,7 @@ export module mean_field:preconditioning.stellar_structure;
 
 export import :preconditioning.gravity_field;
 export import :preconditioning.material_surface;
+export import :preconditioning.stellar_equilibrium;
 
 export namespace mean_field::preconditioning {
     struct IndependentStellarSubsystems final { };
@@ -626,28 +627,88 @@ export namespace mean_field::preconditioning {
         }
     };
 
+    /*
+     * Material/surface execution and stellar-structure execution are separate
+     * capabilities.  The latter also owns the physical cross-Jacobian and
+     * gravity-context wiring, which currently target the legacy prepared core.
+     * Add future cores here only together with matching cross-coupling and
+     * preparation implementations.
+     */
+    template <typename PhysicalCore>
+    struct StellarStructureExecutableRuntime {
+        static constexpr bool available = false;
+    };
+
+    template <>
+    struct StellarStructureExecutableRuntime<operators::PreparedStellarEquilibriumOperator> {
+        static constexpr bool available = true;
+    };
+
+    template <typename PhysicalCore>
+    concept ExecutableStellarStructureRuntimeFor = requires {
+        {
+            StellarStructureExecutableRuntime<std::remove_cvref_t<PhysicalCore>>::available
+        } -> std::convertible_to<bool>;
+        requires StellarStructureExecutableRuntime<std::remove_cvref_t<PhysicalCore>>::available;
+    };
+
+    template <typename Descriptor, typename PhysicalCore>
+    concept StellarStructureRuntimeFor =
+        MaterialSurfaceRuntimeFor<Descriptor, PhysicalCore> &&
+        ExecutableStellarStructureRuntimeFor<PhysicalCore>;
+
+    template <typename Candidate>
+    concept StellarStructurePreconditionerProblem =
+        equilibrium::DiscretizedStellarEquilibriumProblem<Candidate> &&
+        DefaultStellarStructurePhysicalTopologySupportedFor<
+            typename std::remove_cvref_t<Candidate>::ModelType> &&
+        requires {
+            requires StellarStructureRuntimeFor<
+                MaterialSurfaceDescriptorFor<std::remove_cvref_t<Candidate>>,
+                typename std::remove_cvref_t<Candidate>::PhysicalCoreType>;
+        };
+
     namespace detail {
-        template <equilibrium::StellarEquilibriumModel Model>
-        [[nodiscard]] const operators::PreparedStellarEquilibriumOperator &
-        physicalOperator(const equilibrium::StellarEquilibriumProblem<Model> &problem) {
-            if constexpr (equilibrium::StellarEquilibriumProblem<Model>::hasFixedCentralDensity) {
-                return problem.GetPreparedOperator().GetPhysicalOperator();
-            } else {
-                return problem.GetPreparedOperator();
-            }
+        template <StellarStructurePreconditionerProblem Problem>
+        [[nodiscard]] const auto &physicalOperator(const Problem &problem) {
+            return problem.GetPhysicalOperator();
         }
     } // namespace detail
 
+    template <typename Problem, typename MaterialComponent, typename GravityComponent>
+    concept StellarStructurePreparableFor =
+        StellarStructurePreconditionerProblem<std::remove_cvref_t<Problem>> &&
+        PreconditionerComponent<std::remove_cvref_t<MaterialComponent>> &&
+        PreconditionerComponent<std::remove_cvref_t<GravityComponent>> &&
+        requires(
+            const std::remove_cvref_t<Problem> &problem,
+            std::remove_cvref_t<MaterialComponent> materialComponent,
+            std::remove_cvref_t<GravityComponent> gravityComponent
+        ) {
+            preconditioning::prepare(problem, std::move(materialComponent));
+            preconditioning::prepare(
+                problem.GetPhysicalOperator().GetHydrostaticOperator().GetFEM(),
+                problem.GetPhysicalOperator().GetGravityContext().GetGeometryContext(),
+                std::move(gravityComponent)
+            );
+            StellarStructureCrossJacobianOperator{problem.GetPhysicalOperator()};
+        };
+
     template <
         equilibrium::StellarEquilibriumModel Model,
+        equilibrium::StellarDiscretizationType Discretization,
         typename MaterialComponent,
         backend::Registered GravityMassBackend,
         backend::ApplicationMode Mode,
         GravityFactorizationPolicy GravityPolicy,
         StellarStructureFactorizationPolicy StructurePolicy>
+        requires StellarStructurePreparableFor<
+            equilibrium::StellarEquilibriumProblem<Model, Discretization>,
+            MaterialComponent,
+            GravityFieldBlock<GravityMassBackend, backend::HypreBoomerAMG<Mode>, GravityPolicy>>
     class PreparedStellarStructureBlock final : public mfem::Solver {
     private:
-        using Problem          = equilibrium::StellarEquilibriumProblem<Model>;
+        using Problem          = equilibrium::StellarEquilibriumProblem<Model, Discretization>;
         using GravityComponent = GravityFieldBlock<GravityMassBackend, backend::HypreBoomerAMG<Mode>, GravityPolicy>;
         using Structure        = StellarStructureBlock<
             MaterialComponent,
@@ -769,7 +830,7 @@ export namespace mean_field::preconditioning {
     };
 
     template <
-        equilibrium::DiscretizedStellarEquilibriumProblem Problem,
+        StellarStructurePreconditionerProblem Problem,
         typename MaterialComponent,
         backend::Registered GravityMassBackend,
         backend::ApplicationMode Mode,
@@ -792,7 +853,7 @@ export namespace mean_field::preconditioning {
         };
     }
 
-    template <equilibrium::DiscretizedStellarEquilibriumProblem Problem>
+    template <StellarStructurePreconditionerProblem Problem>
     [[nodiscard]] constexpr auto stellarStructureBlock(const Problem &problem) {
         using FixedAMG = backend::HypreBoomerAMG<backend::FixedCycles>;
         auto material  = materialSurfaceBlock(problem);
@@ -805,25 +866,30 @@ export namespace mean_field::preconditioning {
 
     template <
         equilibrium::StellarEquilibriumModel Model,
+        equilibrium::StellarDiscretizationType Discretization,
         typename MaterialComponent,
         backend::Registered GravityMassBackend,
         backend::ApplicationMode Mode,
         GravityFactorizationPolicy GravityPolicy,
         StellarStructureFactorizationPolicy StructurePolicy>
+        requires StellarStructurePreparableFor<
+            equilibrium::StellarEquilibriumProblem<Model, Discretization>,
+            MaterialComponent,
+            GravityFieldBlock<GravityMassBackend, backend::HypreBoomerAMG<Mode>, GravityPolicy>>
     [[nodiscard]] auto prepare(
-        const equilibrium::StellarEquilibriumProblem<Model> &problem,
+        const equilibrium::StellarEquilibriumProblem<Model, Discretization> &problem,
         StellarStructureBlock<
             MaterialComponent,
             GravityFieldBlock<
                 GravityMassBackend,
                 backend::HypreBoomerAMG<Mode>,
                 GravityPolicy>,
-            typename equilibrium::StellarEquilibriumProblem<Model>::FormType,
-            typename equilibrium::StellarEquilibriumProblem<Model>::JacobianFormType,
+            typename equilibrium::StellarEquilibriumProblem<Model, Discretization>::FormType,
+            typename equilibrium::StellarEquilibriumProblem<Model, Discretization>::JacobianFormType,
             StructurePolicy> structure
     ) {
         return PreparedStellarStructureBlock<
-            Model, MaterialComponent, GravityMassBackend, Mode, GravityPolicy, StructurePolicy>{
+            Model, Discretization, MaterialComponent, GravityMassBackend, Mode, GravityPolicy, StructurePolicy>{
             problem, std::move(structure)
         };
     }