feat(libmeanfield): centrifugal + pressure

libmeanfield/impl/analysis/integral.cpp

@@ -1,53 +1,110 @@
 module;
+#include <array>
 #include <mfem.hpp>
 
 module mean_field;
 import :mapping.coefficients;
 
+namespace {
+    template <typename FormT>
+    const mfem::IntegrationRule &get_density_rule(
+        const mean_field::fem::FEM &fem,
+        const mfem::ElementTransformation &transformation,
+        const std::array<
+            int,
+            FormT::dynamicOrderCount> &dynamic_orders = {},
+        const mean_field::utils::DOMAINS domain =
+            mean_field::utils::DOMAINS::ALL
+    ) {
+        using DensityField =
+            mean_field::field::Field<mean_field::field::Density>;
+
+        const mean_field::quadrature::Query query =
+            DensityField::make_query<FormT>(
+                mean_field::quadrature::QuadratureRole::diagnostic,
+                transformation.OrderW(), dynamic_orders, domain,
+                fem.has_mapping() ? mean_field::quadrature::MappingKind::general
+                                  : mean_field::quadrature::MappingKind::none
+            );
+
+        return *fem.quadratureFactory
+                    ->get(query, transformation.GetGeometryType())
+                    .integration_rule;
+    }
+} // namespace
+
 namespace mean_field::analysis {
-    double domain_integrate_grid_function(const fem::FEM &fem, const mfem::GridFunction &gf, utils::DOMAINS domain, mapping::COORDINATE_SPACE coord_space) {
-        mfem::LinearForm lf(fem.H1_fes.get());
+    double domain_integrate_grid_function(
+        const fem::FEM &fem,
+        const mfem::GridFunction &gf,
+        utils::DOMAINS domain,
+        mapping::COORDINATE_SPACE coord_space
+    ) {
+        mfem::LinearForm lf(fem.densityFes.get());
         mfem::GridFunctionCoefficient gf_c(&gf);
         double local_integral;
         mfem::Array<int> elem_markers;
         populate_element_mask(fem.mesh.get(), domain, elem_markers);
+        const mfem::ElementTransformation &representative_transformation =
+            *fem.mesh->GetElementTransformation(0);
+        const mfem::IntegrationRule &integration_rule =
+            get_density_rule<field::Density::Form::MassConservation>(
+                fem, representative_transformation, {}, domain
+            );
 
-        if (fem.has_mapping() && coord_space == mapping::COORDINATE_SPACE::PHYSICAL) {
+        if (fem.has_mapping() &&
+            coord_space == mapping::COORDINATE_SPACE::PHYSICAL) {
             mapping::MappedScalarCoefficient mapped_gf_c(*fem.mapping, gf_c);
 
-            // ReSharper disable once CppDFAMemoryLeak // Disabled because MFEM takes ownership so memory is not leaked
+            // ReSharper disable once CppDFAMemoryLeak // Disabled because MFEM
+            // takes ownership so memory is not leaked
             auto *lf_integrator = new mfem::DomainLFIntegrator(mapped_gf_c);
-            lf_integrator->SetIntRule(fem.int_rule.get());
+            lf_integrator->SetIntRule(&integration_rule);
             lf.AddDomainIntegrator(lf_integrator, elem_markers);
             lf.Assemble();
 
-
             local_integral = lf.Sum();
         } else {
             if (coord_space == mapping::COORDINATE_SPACE::PHYSICAL) {
                 MFEM_ABORT(
-                    "Physical evaluation mode requested but no mapping provided. Check domain bounds and mapping setup.");
+                    "Physical evaluation mode requested but no mapping "
+                    "provided. Check "
+                    "domain bounds and mapping setup."
+                );
             }
-            lf.AddDomainIntegrator(new mfem::DomainLFIntegrator(gf_c), elem_markers);
+            auto *lf_integrator = new mfem::DomainLFIntegrator(gf_c);
+            lf_integrator->SetIntRule(&integration_rule);
+            lf.AddDomainIntegrator(lf_integrator, elem_markers);
             lf.Assemble();
             local_integral = lf.Sum();
         }
 
         double global_integral = 0.0;
-        MPI_Allreduce(&local_integral, &global_integral, 1, MPI_DOUBLE, MPI_SUM, fem.H1_fes->GetComm());
+        MPI_Allreduce(
+            &local_integral, &global_integral, 1, MPI_DOUBLE, MPI_SUM,
+            fem.mesh->GetComm()
+        );
         return global_integral;
     }
 
-    mfem::Vector get_com(const fem::FEM &fem, const mfem::GridFunction &rho) {
+    mfem::Vector get_com(
+        const fem::FEM &fem,
+        const mfem::GridFunction &rho
+    ) {
         const int dim = fem.mesh->Dimension();
         mfem::Vector local_com(dim);
-        local_com = 0.0;
+        local_com         = 0.0;
         double local_mass = 0.0;
 
-        for (int i = 0; i < fem.H1_fes->GetNE(); ++i) {
-            if (fem.mesh->GetAttribute(i) == 3) continue;
-            mfem::ElementTransformation *trans = fem.H1_fes->GetElementTransformation(i);
-            const mfem::IntegrationRule &ir = *fem.int_rule;
+        for (int i = 0; i < fem.mesh->GetNE(); ++i) {
+            if (fem.mesh->GetAttribute(i) == 3)
+                continue;
+            mfem::ElementTransformation *trans =
+                fem.mesh->GetElementTransformation(i);
+            const mfem::IntegrationRule &ir =
+                get_density_rule<field::Density::Form::CenterOfMass>(
+                    fem, *trans, std::array<int, 1>{1}, utils::DOMAINS::STELLAR
+                );
 
             for (int j = 0; j < ir.GetNPoints(); ++j) {
                 const mfem::IntegrationPoint &ip = ir.IntPoint(j);
@@ -77,11 +134,14 @@ namespace mean_field::analysis {
 
         double global_mass = 0.0;
         mfem::Vector global_com(dim);
-        MPI_Comm comm = fem.H1_fes->GetComm();
+        MPI_Comm comm = fem.mesh->GetComm();
 
         MPI_Allreduce(&local_mass, &global_mass, 1, MPI_DOUBLE, MPI_SUM, comm);
 
-        MPI_Allreduce(local_com.GetData(), global_com.GetData(), dim, MPI_DOUBLE, MPI_SUM, comm);
+        MPI_Allreduce(
+            local_com.GetData(), global_com.GetData(), dim, MPI_DOUBLE, MPI_SUM,
+            comm
+        );
 
         if (global_mass > 1e-18) {
             global_com /= global_mass;
@@ -92,19 +152,32 @@ namespace mean_field::analysis {
         return global_com;
     }
 
-    void conserve_mass(const fem::FEM &fem, mfem::GridFunction &rho, const double target_mass) {
-        if (const double current_mass = domain_integrate_grid_function(fem, rho, utils::DOMAINS::STELLAR); current_mass > 1e-15)
+    void conserve_mass(
+        const fem::FEM &fem,
+        mfem::GridFunction &rho,
+        const double target_mass
+    ) {
+        if (const double current_mass = domain_integrate_grid_function(
+                fem, rho, utils::DOMAINS::STELLAR
+            );
+            current_mass > 1e-15)
             rho *= (target_mass / current_mass);
     }
 
-    double get_moment_of_inertia(const fem::FEM &fem, const mfem::GridFunction &rho) {
+    double get_moment_of_inertia(
+        const fem::FEM &fem,
+        const mfem::GridFunction &rho
+    ) {
         auto s2_func = [](const mfem::Vector &x) {
             return std::pow(x(0), 2) + std::pow(x(1), 2);
         };
 
         std::unique_ptr<mfem::Coefficient> s2_coeff;
         if (fem.has_mapping()) {
-            s2_coeff = std::make_unique<mapping::PhysicalPositionFunctionCoefficient>(*fem.mapping, s2_func);
+            s2_coeff =
+                std::make_unique<mapping::PhysicalPositionFunctionCoefficient>(
+                    *fem.mapping, s2_func
+                );
         } else {
             s2_coeff = std::make_unique<mfem::FunctionCoefficient>(s2_func);
         }
@@ -112,53 +185,82 @@ namespace mean_field::analysis {
         mfem::GridFunctionCoefficient rho_coeff(&rho);
         mfem::ProductCoefficient I_integrand(rho_coeff, *s2_coeff);
 
-        mfem::LinearForm I_lf(fem.H1_fes.get());
+        mfem::LinearForm I_lf(fem.densityFes.get());
+        const mfem::ElementTransformation &representative_transformation =
+            *fem.mesh->GetElementTransformation(0);
+        const mfem::IntegrationRule &integration_rule =
+            get_density_rule<field::Density::Form::Quadrupole>(
+                fem, representative_transformation, std::array<int, 1>{2},
+                utils::DOMAINS::STELLAR
+            );
+        mfem::Array<int> stellar_markers;
+        populate_element_mask(
+            fem.mesh.get(), utils::DOMAINS::STELLAR, stellar_markers
+        );
 
-        double I = 0.0;
-        // TODO: Need to filter here to just the stellar domain and also update the IntRule
+        double local_I = 0.0;
         if (fem.has_mapping()) {
-            mapping::MappedScalarCoefficient mapped_integrand(*fem.mapping, I_integrand);
-            I_lf.AddDomainIntegrator(new mfem::DomainLFIntegrator(mapped_integrand));
+            mapping::MappedScalarCoefficient mapped_integrand(
+                *fem.mapping, I_integrand
+            );
+            auto *integrator = new mfem::DomainLFIntegrator(mapped_integrand);
+            integrator->SetIntRule(&integration_rule);
+            I_lf.AddDomainIntegrator(integrator, stellar_markers);
             I_lf.Assemble();
-            I = I_lf.Sum();
+            local_I = I_lf.Sum();
         } else {
-            I_lf.AddDomainIntegrator(new mfem::DomainLFIntegrator(I_integrand));
+            auto *integrator = new mfem::DomainLFIntegrator(I_integrand);
+            integrator->SetIntRule(&integration_rule);
+            I_lf.AddDomainIntegrator(integrator, stellar_markers);
             I_lf.Assemble();
-            I = I_lf.Sum();
+            local_I = I_lf.Sum();
         }
 
-        return I;
+        double global_I = 0.0;
+        MPI_Allreduce(
+            &local_I, &global_I, 1, MPI_DOUBLE, MPI_SUM, fem.mesh->GetComm()
+        );
+        return global_I;
     }
 
     double get_mesh_volume(
-        const fem::FEM& fem,
+        const fem::FEM &fem,
         const mapping::COORDINATE_SPACE coordinate_space,
         const utils::DOMAINS domain
     ) {
         mfem::ParMesh &mesh = *fem.mesh;
-        const mapping::DomainMapper &map = *fem.mapping;
-        const mfem::IntegrationRule &ir = *fem.int_rule;
-
         const bool physical =
             (coordinate_space == mapping::COORDINATE_SPACE::PHYSICAL);
 
+        if (physical && !fem.has_mapping()) {
+            MFEM_ABORT(
+                "Physical volume requested but no domain mapping is available."
+            );
+        }
+
         double local_volume = 0.0;
 
         for (int e = 0; e < mesh.GetNE(); ++e) {
             const int attr = mesh.GetAttribute(e);
             switch (domain) {
-                case utils::DOMAINS::ALL:
-                    break;
-                case utils::DOMAINS::STELLAR:
-                    if (attr == 3) continue;
-                    break;
-                case utils::DOMAINS::VACUUM:
-                    if (attr != 3) continue;
-                    break;
-                default:
-                    MFEM_ABORT("Unsupported domain type for volume computation.");
+            case utils::DOMAINS::ALL:
+                break;
+            case utils::DOMAINS::STELLAR:
+                if (attr == 3)
+                    continue;
+                break;
+            case utils::DOMAINS::VACUUM:
+                if (attr != 3)
+                    continue;
+                break;
+            default:
+                MFEM_ABORT("Unsupported domain type for volume computation.");
             }
             mfem::ElementTransformation *T = mesh.GetElementTransformation(e);
+            const mfem::IntegrationRule &ir =
+                get_density_rule<field::Density::Form::MassConservation>(
+                    fem, *T, {}, domain
+                );
 
             for (int q = 0; q < ir.GetNPoints(); ++q) {
                 const mfem::IntegrationPoint &ip = ir.IntPoint(q);
@@ -167,7 +269,7 @@ namespace mean_field::analysis {
                 double dV = ip.weight * T->Weight();
 
                 if (physical) {
-                    dV *= std::fabs(map.ComputeDetJ(*T, ip));
+                    dV *= std::fabs(fem.mapping->ComputeDetJ(*T, ip));
                 }
 
                 local_volume += dV;
@@ -175,8 +277,10 @@ namespace mean_field::analysis {
         }
 
         double global_volume = 0.0;
-        MPI_Allreduce(&local_volume, &global_volume, 1, MPI_DOUBLE, MPI_SUM,
-                      mesh.GetComm());
+        MPI_Allreduce(
+            &local_volume, &global_volume, 1, MPI_DOUBLE, MPI_SUM,
+            mesh.GetComm()
+        );
         return global_volume;
     }
-}
+} // namespace mean_field::analysis

libmeanfield/impl/fem.cpp

@@ -1,190 +1,560 @@
 module;
-#include <string>
+
+#include <algorithm>
+#include <cmath>
+#include <expected>
+#include <limits>
 #include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
 
 #include <mfem.hpp>
 #include <stroid/stroid.h>
 
 module mean_field;
+
 import :boundary.contexts;
+import :field.mfem;
 import :mapping.coefficients;
 import :utils.misc;
 import :utils.user;
 
-
 namespace mean_field::fem {
-    FEM setup_fem(const std::string &filename, const utils::Args &args, const int extra_refine) {
+    FEM setup_fem(
+        const std::string &filename,
+        const utils::Args &args,
+        const int extraRefine
+    ) {
         FEM fem;
 
-        //==================================================================
-        // Section 1: Mesh and FE Space Setup
-        //==================================================================
-        fem.smesh = stroid::IO::LoadStroidMesh(filename).value();
-        if (extra_refine > 0) {
-            stroid::refinement::UniformRefinement(fem.smesh, extra_refine);
+        using GravityPotential   = field::Gravity::Potential;
+        using GravityFlux        = field::Gravity::Flux;
+        using DisplacementVector = field::Displacement::Vector;
+        using DensityScalar      = field::Density::Scalar;
+        using EnthalpyScalar     = field::Enthalpy::Scalar;
+
+        // =====================================================================
+        // Section 1: Mesh construction
+        // =====================================================================
+
+        fem.smesh                = stroid::IO::LoadStroidMesh(filename).value();
+
+        if (extraRefine > 0) {
+            stroid::refinement::UniformRefinement(fem.smesh, extraRefine);
         }
 
-        fem.mesh = std::make_unique<mfem::ParMesh>(MPI_COMM_WORLD, *fem.smesh.mesh);
+        int mpiSize = 1;
+        MPI_Comm_size(MPI_COMM_WORLD, &mpiSize);
+
+        const std::unique_ptr<int[]> meshPartitioning(
+            fem.smesh.mesh->GeneratePartitioning(mpiSize, 1)
+        );
+
+        fem.mesh = std::make_unique<mfem::ParMesh>(
+            MPI_COMM_WORLD, *fem.smesh.mesh, meshPartitioning.get(), 1
+        );
+
         fem.mesh->EnsureNodes();
 
-        const int geom_order = utils::get_mesh_order(*fem.mesh);
-        const int dim = fem.mesh->Dimension();
+        // =====================================================================
+        // Section 2: Exterior compactification coordinate
+        // =====================================================================
 
-        const int v_order = 2;
-        const int rho_order = 2;
-        const int p = rho_order ;
+        if (fem.smesh.exterior_coordinate == nullptr) {
+            throw std::runtime_error("Exterior coordinate not set.");
+        }
 
-        const int cb_type = mfem::BasisType::GaussLobatto;
-        const int ob_type = mfem::BasisType::IntegratedGLL;
+        if (fem.smesh.exterior_coordinate->space == nullptr) {
+            throw std::runtime_error("Space for exterior coordinate not set.");
+        }
 
-        fem.RT_fec = std::make_unique<mfem::RT_FECollection>(p, dim, cb_type, ob_type);
-        fem.RT_fes = std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.RT_fec.get());
+        if (fem.smesh.exterior_coordinate->values == nullptr) {
+            throw std::runtime_error("Values for exterior coordinate not set.");
+        }
 
-        fem.H1_fec = std::make_unique<mfem::H1_FECollection>(v_order, dim);
-        fem.L2_fec = std::make_unique<mfem::L2_FECollection>(rho_order, dim);
+        const mfem::FiniteElementSpace &serialCoordinateSpace =
+            *fem.smesh.exterior_coordinate->space;
 
-        // Gravity (Scalar H1) and Velocity (Vector H1)
-        fem.H1_fes = std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.H1_fec.get());
-        fem.Vec_H1_fes = std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.H1_fec.get(), dim,
-                                                                       mfem::Ordering::byNODES);
+        const mfem::GridFunction &serialCoordinate =
+            *fem.smesh.exterior_coordinate->values;
 
-        // Density & Pressure (Scalar Discontinuous L2)
-        fem.L2_fes = std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.L2_fec.get());
+        if (serialCoordinate.FESpace() != &serialCoordinateSpace) {
+            throw std::runtime_error(
+                "Exterior coordinate values are not associated with the "
+                "supplied finite-element space."
+            );
+        }
 
-        //==================================================================
-        // Section 2: Domain Mapping
-        //==================================================================
-        auto [r_star_ref, r_inf_ref] = utils::discover_bounds(fem.mesh.get(), 3)
-                .or_else([](const boundary::BoundsError &err)-> std::expected<boundary::Bounds, boundary::BoundsError> {
-                    throw std::runtime_error("Unable to determine vacuum domain reference boundary...");
-                }).value();
+        if (serialCoordinateSpace.GetMesh() != fem.smesh.mesh.get()) {
+            throw std::runtime_error(
+                "Exterior coordinate space is not associated with the "
+                "loaded STROID mesh."
+            );
+        }
 
-        fem.mapping = std::make_unique<mapping::DomainMapper>(r_star_ref, r_inf_ref);
+        if (serialCoordinateSpace.GetVDim() != 1) {
+            throw std::runtime_error(
+                "Exterior coordinate must be a scalar field."
+            );
+        }
 
-        //==================================================================
-        // Section 3: Multi-physics Block-offsets
-        //==================================================================
-        fem.block_true_offsets.SetSize(3);
-        fem.block_true_offsets[0] = 0;
-        fem.block_true_offsets[1] = fem.Vec_H1_fes->GetTrueVSize();
-        fem.block_true_offsets[2] = fem.block_true_offsets[1] + fem.L2_fes->GetTrueVSize();
+        if (serialCoordinate.Size() != serialCoordinateSpace.GetVSize()) {
+            throw std::runtime_error(
+                "Exterior coordinate value count does not match its "
+                "finite-element space."
+            );
+        }
 
-        fem.gravity_block_true_offsets.SetSize(3);
-        fem.gravity_block_true_offsets[0] = 0;
-        fem.gravity_block_true_offsets[1] = fem.RT_fes->GetTrueVSize();
-        fem.gravity_block_true_offsets[2] = fem.gravity_block_true_offsets[1] + fem.L2_fes->GetTrueVSize();
+        const int compactificationOrder =
+            serialCoordinateSpace.GetMaxElementOrder();
 
-        //==================================================================
-        // Section 4: Multipole BC setup.
-        //==================================================================
-        fem.com.SetSize(dim);
+        const int dimension     = fem.mesh->Dimension();
+
+        fem.compactificationFec = std::make_unique<mfem::H1_FECollection>(
+            compactificationOrder, dimension
+        );
+
+        fem.compactificationFes = std::make_unique<mfem::ParFiniteElementSpace>(
+            fem.mesh.get(), fem.compactificationFec.get()
+        );
+
+        mfem::ParGridFunction distributedCoordinate(
+            fem.mesh.get(), &serialCoordinate, meshPartitioning.get()
+        );
+
+        if (distributedCoordinate.Size() !=
+            fem.compactificationFes->GetVSize()) {
+            throw std::runtime_error(
+                "Distributed exterior coordinate does not match the "
+                "constructed parallel finite-element space."
+            );
+        }
+
+        fem.compactificationCoordinate =
+            std::make_unique<mfem::ParGridFunction>(
+                fem.compactificationFes.get()
+            );
+
+        *fem.compactificationCoordinate = distributedCoordinate;
+
+        double localMinimum = std::numeric_limits<double>::infinity();
+
+        double localMaximum = -std::numeric_limits<double>::infinity();
+
+        for (int index = 0; index < fem.compactificationCoordinate->Size();
+             ++index) {
+            const double value = (*fem.compactificationCoordinate)(index);
+
+            if (!std::isfinite(value)) {
+                throw std::runtime_error(
+                    "Exterior coordinate contains a non-finite value."
+                );
+            }
+
+            localMinimum = std::min(localMinimum, value);
+
+            localMaximum = std::max(localMaximum, value);
+        }
+
+        double globalMinimum = 0.0;
+        double globalMaximum = 0.0;
+
+        MPI_Allreduce(
+            &localMinimum, &globalMinimum, 1, MPI_DOUBLE, MPI_MIN,
+            MPI_COMM_WORLD
+        );
+
+        MPI_Allreduce(
+            &localMaximum, &globalMaximum, 1, MPI_DOUBLE, MPI_MAX,
+            MPI_COMM_WORLD
+        );
+
+        constexpr double coordinateTolerance = 1.0e-12;
+
+        if (globalMinimum < -coordinateTolerance ||
+            globalMaximum > 1.0 + coordinateTolerance) {
+            throw std::runtime_error(
+                "Exterior coordinate lies outside the expected "
+                "interval [0, 1]."
+            );
+        }
+
+        // =====================================================================
+        // Section 3: Compile-time field realization
+        // =====================================================================
+
+        // ---------------------------------------------------------------------
+        // Gravity potential: scalar L2
+        // ---------------------------------------------------------------------
+
+        fem.gravityPotentialFec =
+            GravityField::make_fec<GravityPotential>(dimension);
+
+        fem.gravityPotentialFes = GravityField::make_fespace<GravityPotential>(
+            *fem.mesh, *fem.gravityPotentialFec
+        );
+
+        // ---------------------------------------------------------------------
+        // Gravity flux: H(div)/RT. Basis choices are encoded by field.mfem.
+        // ---------------------------------------------------------------------
+
+        fem.gravityFluxFec = GravityField::make_fec<GravityFlux>(dimension);
+
+        fem.gravityFluxFes = GravityField::make_fespace<GravityFlux>(
+            *fem.mesh, *fem.gravityFluxFec
+        );
+
+        // ---------------------------------------------------------------------
+        // Displacement: vector H1. Ordering is encoded by field.mfem.
+        // ---------------------------------------------------------------------
+
+        fem.displacementFec =
+            DisplacementField::make_fec<DisplacementVector>(dimension);
+
+        fem.displacementFes =
+            DisplacementField::make_fespace<DisplacementVector>(
+                *fem.mesh, *fem.displacementFec
+            );
+
+        fem.displacement =
+            std::make_unique<mfem::ParGridFunction>(fem.displacementFes.get());
+
+        *fem.displacement = 0.0;
+
+        // ---------------------------------------------------------------------
+        // Density: scalar discontinuous L2
+        // ---------------------------------------------------------------------
+
+        fem.densityFec    = DensityField::make_fec<DensityScalar>(dimension);
+
+        fem.densityFes    = DensityField::make_fespace<DensityScalar>(
+            *fem.mesh, *fem.densityFec
+        );
+
+        // ---------------------------------------------------------------------
+        // Specific enthalpy: scalar continuous H1
+        // ---------------------------------------------------------------------
+
+        fem.enthalpyFec = EnthalpyField::make_fec<EnthalpyScalar>(dimension);
+
+        fem.enthalpyFes = EnthalpyField::make_fespace<EnthalpyScalar>(
+            *fem.mesh, *fem.enthalpyFec
+        );
+
+        // =====================================================================
+        // Section 4: Domain mapping
+        // =====================================================================
+
+        auto [stellarRadiusReference, infinityRadiusReference] =
+            utils::discover_bounds(fem.mesh.get(), 3)
+                .or_else(
+                    [](const boundary::BoundsError &)
+                        -> std::expected<
+                            boundary::Bounds, boundary::BoundsError> {
+                        throw std::runtime_error(
+                            "Unable to determine vacuum-domain reference "
+                            "boundaries."
+                        );
+                    }
+                )
+                .value();
+
+        fem.mapping = std::make_unique<mapping::DomainMapper>(
+            *fem.displacement, stellarRadiusReference, infinityRadiusReference
+        );
+
+        // =====================================================================
+        // Section 5: Block offsets
+        //
+        // Legacy layouts only. New coupled operators use :utils.blocks forms.
+        //
+        // Main system:    [Displacement | Density]
+        // Gravity system: [Flux | Potential]
+        // =====================================================================
+
+        fem.blockTrueOffsets.SetSize(3);
+        fem.blockTrueOffsets[0] = 0;
+
+        fem.blockTrueOffsets[1] = fem.displacementFes->GetTrueVSize();
+
+        fem.blockTrueOffsets[2] =
+            fem.blockTrueOffsets[1] + fem.densityFes->GetTrueVSize();
+
+        fem.gravityBlockTrueOffsets.SetSize(3);
+        fem.gravityBlockTrueOffsets[0] = 0;
+
+        fem.gravityBlockTrueOffsets[1] = fem.gravityFluxFes->GetTrueVSize();
+
+        fem.gravityBlockTrueOffsets[2] =
+            fem.gravityBlockTrueOffsets[1] +
+            fem.gravityPotentialFes->GetTrueVSize();
+
+        // =====================================================================
+        // Section 6: Multipole data
+        // =====================================================================
+
+        fem.com.SetSize(dimension);
         fem.com = 0.0;
-        fem.Q.SetSize(dim, dim);
+
+        fem.Q.SetSize(dimension, dimension);
         fem.Q = 0.0;
 
-        //==================================================================
-        // Section 5: Integration Rules
-        //==================================================================
-        MFEM_ASSERT(fem.mesh->GetElementGeometry(0) == mfem::Geometry::CUBE,
-                    "Currently only hexahedral meshes are supported");
-        const int element_order = fem.H1_fes->GetMaxElementOrder();
-        fem.int_order = 2 * element_order + geom_order - 2 + args.quad_boost;
+        // =====================================================================
+        // Section 7: Essential boundaries and domain masks
+        // =====================================================================
 
-        fem.int_rule = std::make_unique<mfem::IntegrationRule>(mfem::IntRules.Get(mfem::Geometry::CUBE, fem.int_order));
+        fem.essentialDisplacementTdofs.SetSize(0);
 
-        //==================================================================
-        // Section 6: Essential Boundaries & Domain Masks
-        //==================================================================
-        fem.ess_v_tdofs.SetSize(0);
+        populate_element_mask(
+            fem.mesh.get(), utils::DOMAINS::STELLAR,
+            fem.gravityContext.stellar_mask
+        );
 
-        populate_element_mask(fem.mesh.get(), utils::DOMAINS::STELLAR, fem.gravity_context.stellar_mask);
+        const int boundaryAttributeCount = fem.mesh->bdr_attributes.Max();
 
-        const int n_bdr_attrs = fem.mesh->bdr_attributes.Max();
-        fem.boundary_context.inf_bounds.SetSize(n_bdr_attrs);
-        fem.boundary_context.stellar_bounds.SetSize(n_bdr_attrs);
+        fem.boundaryContext.inf_bounds.SetSize(boundaryAttributeCount);
 
-        fem.boundary_context.inf_bounds = 0;
-        fem.boundary_context.stellar_bounds = 0;
+        fem.boundaryContext.stellar_bounds.SetSize(boundaryAttributeCount);
 
-        fem.boundary_context.inf_bounds[static_cast<int>(boundary::Boundaries::INF_SURFACE) - 1] = 1;
-        fem.boundary_context.stellar_bounds[static_cast<int>(boundary::Boundaries::STELLAR_SURFACE) - 1] = 1;
+        fem.boundaryContext.inf_bounds     = 0;
+        fem.boundaryContext.stellar_bounds = 0;
 
-        //==================================================================
-        // Section 7: Gravity Context Setup
-        //==================================================================
-        fem.gravity_context.minres = std::make_unique<mfem::MINRESSolver>(fem.mesh->GetComm());
-        fem.gravity_context.minres->SetRelTol(1e-12);
-        fem.gravity_context.minres->SetAbsTol(1e-12);
-        fem.gravity_context.minres->SetMaxIter(1000);
-        fem.gravity_context.minres->SetPrintLevel(0);
+        fem.boundaryContext.inf_bounds
+            [static_cast<int>(boundary::Boundaries::INF_SURFACE) - 1] = 1;
 
-        fem.gravity_context.prec_Phi = std::make_unique<mfem::HypreBoomerAMG>();
-        fem.gravity_context.prec_Phi->SetPrintLevel(0);
+        fem.boundaryContext.stellar_bounds
+            [static_cast<int>(boundary::Boundaries::STELLAR_SURFACE) - 1] = 1;
 
-        fem.gravity_context.block_prec = std::make_unique<mfem::BlockDiagonalPreconditioner>(fem.gravity_block_true_offsets);
+        // =====================================================================
+        // Section 8: Gravity solver context
+        // =====================================================================
+
+        fem.gravityContext.minres =
+            std::make_unique<mfem::MINRESSolver>(fem.mesh->GetComm());
+
+        fem.gravityContext.minres->SetRelTol(1.0e-12);
+        fem.gravityContext.minres->SetAbsTol(1.0e-12);
+        fem.gravityContext.minres->SetMaxIter(1000);
+        fem.gravityContext.minres->SetPrintLevel(0);
+
+        fem.gravityContext.prec_Phi = std::make_unique<mfem::HypreBoomerAMG>();
+
+        fem.gravityContext.prec_Phi->SetPrintLevel(0);
+
+        fem.gravityContext.block_prec =
+            std::make_unique<mfem::BlockDiagonalPreconditioner>(
+                fem.gravityBlockTrueOffsets
+            );
+
+        fem.gravityContext.minres->SetPreconditioner(
+            *fem.gravityContext.block_prec
+        );
+
+        // =====================================================================
+        // Section 9: Vacuum true-DOF masks
+        // =====================================================================
 
-        fem.gravity_context.minres->SetPreconditioner(*fem.gravity_context.block_prec);
-        //=========================================================
-        // Section 10: Set All vacuum elements true degrees of freedom
-        //=========================================================
         {
-            mfem::Array<int> vacuum_mask;
-            utils::populate_element_mask(fem.mesh.get(), utils::DOMAINS::VACUUM, vacuum_mask);
+            mfem::Array<int> vacuumMask;
 
-            utils::populate_domain_tdofs(fem.Vec_H1_fes.get(), vacuum_mask, fem.vacuum_tdof_v);
-            utils::populate_domain_tdofs(fem.L2_fes.get(), vacuum_mask, fem.vacuum_tdof_rho);
+            utils::populate_element_mask(
+                fem.mesh.get(), utils::DOMAINS::VACUUM, vacuumMask
+            );
+
+            utils::populate_domain_tdofs(
+                fem.displacementFes.get(), vacuumMask,
+                fem.vacuumDisplacementTdofs
+            );
+
+            utils::populate_domain_tdofs(
+                fem.densityFes.get(), vacuumMask, fem.vacuumDensityTdofs
+            );
+
+            utils::populate_domain_tdofs(
+                fem.enthalpyFes.get(), vacuumMask, fem.vacuumEnthalpyTdofs
+            );
         }
 
-        const quadrature::QuadratureOptions& quadrature_options = args.quadrature;
+        // =====================================================================
+        // Section 10: Quadrature policy
+        // =====================================================================
 
-        if (quadrature_options.validation.reject_negative_boosts && quadrature_options.global_boost < 0) {
-            throw std::invalid_argument("Global quadrature boost cannot be negative.");
+        const quadrature::QuadratureOptions &quadratureOptions =
+            args.quadrature;
+
+        if (quadratureOptions.validation.reject_negative_boosts &&
+            quadratureOptions.global_boost < 0) {
+            throw std::invalid_argument(
+                "Global quadrature boost cannot be negative."
+            );
         }
 
-        quadrature::RuleSet quadrature_rule_set = quadrature::make_rule_set(quadrature_options.mode, quadrature_options.global_boost);
+        quadrature::RuleSet quadratureRuleSet = quadrature::make_rule_set(
+            quadratureOptions.mode, quadratureOptions.global_boost
+        );
 
-        if (quadrature_options.fallback_fixed_order.has_value()) {
-            if (*quadrature_options.fallback_fixed_order < 0) {
-                throw std::invalid_argument("Fallback quadrature order cannot be negative.");
+        if (quadratureOptions.fallback_fixed_order.has_value()) {
+            if (*quadratureOptions.fallback_fixed_order < 0) {
+                throw std::invalid_argument(
+                    "Fallback quadrature order cannot be negative."
+                );
             }
-            quadrature_rule_set.fallback.fixed_order = quadrature_options.fallback_fixed_order;
+
+            quadratureRuleSet.fallback.fixed_order =
+                quadratureOptions.fallback_fixed_order;
         }
 
-        auto apply_quadrature_options = [&quadrature_options](quadrature::RuleControl& rule_control, const quadrature::QuadratureTermOptions& term_options) {
-            if (term_options.fixed_order.has_value() && *term_options.fixed_order < 0) {
-                throw std::invalid_argument("Fixed quadrature order cannot be negative.");
-            }
+        auto apply_quadrature_options =
+            [&quadratureOptions](
+                quadrature::RuleControl &ruleControl,
+                const quadrature::QuadratureTermOptions &termOptions
+            ) {
+                if (termOptions.fixed_order.has_value() &&
+                    *termOptions.fixed_order < 0) {
+                    throw std::invalid_argument(
+                        "Fixed quadrature order cannot be negative."
+                    );
+                }
 
-            if (quadrature_options.validation.reject_negative_boosts && term_options.additional_boost < 0) {
-                throw std::invalid_argument("Term quadrature boost cannot be negative.");
-            }
+                if (quadratureOptions.validation.reject_negative_boosts &&
+                    termOptions.additional_boost < 0) {
+                    throw std::invalid_argument(
+                        "Term quadrature boost cannot be negative."
+                    );
+                }
 
-            rule_control.boost += term_options.additional_boost;
+                ruleControl.boost += termOptions.additional_boost;
 
-            if (term_options.fixed_order.has_value()) {
-                rule_control.fixed_order = term_options.fixed_order;
-            }
-        };
+                if (termOptions.fixed_order.has_value()) {
+                    ruleControl.fixed_order = termOptions.fixed_order;
+                }
+            };
 
-        apply_quadrature_options(quadrature_rule_set.gravity_hdiv_mass, quadrature_options.gravity_hdiv_mass);
-        apply_quadrature_options(quadrature_rule_set.gravity_divergence, quadrature_options.gravity_divergence);
-        apply_quadrature_options(quadrature_rule_set.gravity_source, quadrature_options.gravity_source);
-        apply_quadrature_options(quadrature_rule_set.gravity_boundary, quadrature_options.gravity_boundary);
-        apply_quadrature_options(quadrature_rule_set.density_projection, quadrature_options.density_projection);
-        apply_quadrature_options(quadrature_rule_set.mass_conservation, quadrature_options.mass_conservation);
-        apply_quadrature_options(quadrature_rule_set.center_of_mass, quadrature_options.center_of_mass);
-        apply_quadrature_options(quadrature_rule_set.quadrupole, quadrature_options.quadrupole);
-        apply_quadrature_options(quadrature_rule_set.gravitational_energy, quadrature_options.gravitational_energy);
-        apply_quadrature_options(quadrature_rule_set.virial, quadrature_options.virial);
-        apply_quadrature_options(quadrature_rule_set.error_norm, quadrature_options.error_norm);
+        apply_quadrature_options(
+            quadratureRuleSet.gravity_hdiv_mass,
+            quadratureOptions.gravity_hdiv_mass
+        );
 
-        apply_quadrature_options(quadrature_rule_set.roles.discretization, quadrature_options.roles.discretization);
-        apply_quadrature_options(quadrature_rule_set.roles.preconditioner, quadrature_options.roles.preconditioner);
-        apply_quadrature_options(quadrature_rule_set.roles.diagnostic, quadrature_options.roles.diagnostic);
-        apply_quadrature_options(quadrature_rule_set.roles.projection, quadrature_options.roles.projection);
+        apply_quadrature_options(
+            quadratureRuleSet.gravity_divergence,
+            quadratureOptions.gravity_divergence
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.gravity_source, quadratureOptions.gravity_source
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.gravity_boundary,
+            quadratureOptions.gravity_boundary
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.centrifugal, quadratureOptions.centrifugal
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.density_projection,
+            quadratureOptions.density_projection
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.eos_closure, quadratureOptions.eos_closure
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.hydrostatic_equilibrium,
+            quadratureOptions.hydrostatic_equilibrium
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.isobaric_surface,
+            quadratureOptions.isobaric_surface
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.mesh_extension, quadratureOptions.mesh_extension
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.mass_conservation,
+            quadratureOptions.mass_conservation
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.mass_normalization,
+            quadratureOptions.mass_normalization
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.center_of_mass, quadratureOptions.center_of_mass
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.quadrupole, quadratureOptions.quadrupole
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.gravitational_energy,
+            quadratureOptions.gravitational_energy
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.pressure_integral,
+            quadratureOptions.pressure_integral
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.pressure_force, quadratureOptions.pressure_force
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.virial, quadratureOptions.virial
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.error_norm, quadratureOptions.error_norm
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.roles.discretization,
+            quadratureOptions.roles.discretization
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.roles.preconditioner,
+            quadratureOptions.roles.preconditioner
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.roles.diagnostic,
+            quadratureOptions.roles.diagnostic
+        );
+
+        apply_quadrature_options(
+            quadratureRuleSet.roles.projection,
+            quadratureOptions.roles.projection
+        );
+
+        fem.quadratureFactory = std::make_unique<quadrature::RuleFactory>(
+            quadrature::Policy(std::move(quadratureRuleSet))
+        );
+
+        // =====================================================================
+        // Section 11: Stateless domain mapper
+        // =====================================================================
+
+        auto exteriorDomain = std::make_unique<
+            const mapping::compactification::KelvinCompactification>(
+            args.kelvin_options
+        );
+
+        fem.domainMapperStateless =
+            std::make_unique<mapping::DomainMapperStateless>(
+                args.domain_mapper_options, std::move(exteriorDomain)
+            );
 
-        fem.quadrature_factory = std::make_unique<quadrature::RuleFactory>(quadrature::Policy(std::move(quadrature_rule_set)));
         return fem;
     }
-}
-
+} // namespace mean_field::fem

libmeanfield/impl/integrators/advection.cpp

@@ -4,7 +4,9 @@ module;
 module mean_field;
 
 namespace mean_field::integrators {
-    AdvectionIntegrator::AdvectionIntegrator(const mapping::DomainMapper &map) : m_map(map) {}
+    AdvectionIntegrator::AdvectionIntegrator(const mapping::DomainMapper &map)
+        : m_map(map) {
+    }
 
     void AdvectionIntegrator::AssembleElementVector(
         const mfem::Array<const mfem::FiniteElement *> &el,
@@ -16,17 +18,17 @@ namespace mean_field::integrators {
             return;
         }
 
-        const mfem::FiniteElement *fe_v = el[0];
+        const mfem::FiniteElement *fe_v   = el[0];
         const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector &v_dofs = *elfun[0];
-        const mfem::Vector &rho_dofs = *elfun[1];
+        const mfem::Vector &v_dofs        = *elfun[0];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::Vector &r_v = *elvec[0];
+        mfem::Vector &r_v                 = *elvec[0];
         r_v.SetSize(dof_v * dim);
         r_v = 0.0;
         if (elvec[1]) {
@@ -37,7 +39,8 @@ namespace mean_field::integrators {
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
         mfem::DenseMatrix dshape_v_ref(dof_v, dim), dshape_v_phys(dof_v, dim);
 
-        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder() + 1);
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder() + 1);
 
         for (int q = 0; q < ir->GetNPoints(); q++) {
             const mfem::IntegrationPoint &ip = ir->IntPoint(q);
@@ -80,7 +83,8 @@ namespace mean_field::integrators {
 
             for (int i = 0; i < dof_v; ++i) {
                 for (int c = 0; c < dim; ++c) {
-                    r_v(i + c * dof_v) += shape_v(i) * rho_val * adv_val(c) * weight;
+                    r_v(i + c * dof_v) +=
+                        shape_v(i) * rho_val * adv_val(c) * weight;
                 }
             }
         }
@@ -91,27 +95,30 @@ namespace mean_field::integrators {
         mfem::ElementTransformation &Tr,
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
-    )  {
-        const mfem::FiniteElement *fe_v = el[0];
+    ) {
+        const mfem::FiniteElement *fe_v   = el[0];
         const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector &v_dofs = *elfun[0];
-        const mfem::Vector &rho_dofs = *elfun[1];
+        const mfem::Vector &v_dofs        = *elfun[0];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::DenseMatrix *dv_dv = elmats(0, 0);
-        mfem::DenseMatrix *dv_drho = elmats(0, 1);
+        mfem::DenseMatrix *dv_dv          = elmats(0, 0);
+        mfem::DenseMatrix *dv_drho        = elmats(0, 1);
 
-        if (dv_dv) *dv_dv = 0.0;
-        if (dv_drho) *dv_drho = 0.0;
+        if (dv_dv)
+            *dv_dv = 0.0;
+        if (dv_drho)
+            *dv_drho = 0.0;
 
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
         mfem::DenseMatrix dshape_v_ref(dof_v, dim), dshape_v_phys(dof_v, dim);
 
-        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder() + 1);
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder() + 1);
 
         for (int q = 0; q < ir->GetNPoints(); q++) {
             const mfem::IntegrationPoint &ip = ir->IntPoint(q);
@@ -164,22 +171,27 @@ namespace mean_field::integrators {
                             double v_dot_grad_phi_j = 0.0;
 
                             for (int k = 0; k < dim; ++k) {
-                                v_dot_grad_phi_j += v_val(k) * dshape_v_phys(j, k);
+                                v_dot_grad_phi_j +=
+                                    v_val(k) * dshape_v_phys(j, k);
                             }
 
                             for (int d = 0; d < dim; ++d) {
                                 // Trial function component
-                                int col = j + d * dof_v;
+                                int col      = j + d * dof_v;
 
                                 // \rho (\delta \vec{v} \cdot \nabla \vec{v})
-                                // \delta v is along direction 'd' for the cth component of advection
+                                // \delta v is along direction 'd' for the cth
+                                // component of advection
                                 double termA = shape_v(j) * grad_v(c, d);
 
                                 // \rho(\vec{v} \cdot \nabla \delta \vec{v})
-                                // Only non-zero when the advected component matches the test component
-                                double termB = (c == d) ? v_dot_grad_phi_j : 0.0;
+                                // Only non-zero when the advected component
+                                // matches the test component
+                                double termB =
+                                    (c == d) ? v_dot_grad_phi_j : 0.0;
 
-                                (*dv_dv)(row, col) += shape_v(i) * rho_val * (termA + termB) * weight;
+                                (*dv_dv)(row, col) += shape_v(i) * rho_val *
+                                                      (termA + termB) * weight;
                             }
                         }
                     }
@@ -192,7 +204,7 @@ namespace mean_field::integrators {
                     for (int c = 0; c < dim; ++c) {
                         int row = i + c * dof_v;
                         for (int j = 0; j < dof_rho; ++j) {
-                            int col = j;
+                            int col     = j;
 
                             // \delta \rho * (\vec{v} \cdot \nabla \vec{v})
                             double term = shape_rho(j) * adv_val(c);
@@ -203,4 +215,4 @@ namespace mean_field::integrators {
             }
         }
     }
-}
+} // namespace mean_field::integrators

libmeanfield/impl/integrators/centrifugal.cpp

@@ -3,41 +3,49 @@ module;
 module mean_field;
 
 namespace mean_field::integrators {
-   CentrifugalForceIntegrator::CentrifugalForceIntegrator(
-      const mapping::DomainMapper& map,
-      const mfem::Vector& omega
-   ) : m_map(map), m_omega(3) {
-      MFEM_ASSERT(omega.Size() == 3, "Omega vector must be 3D");
-      m_omega = omega;
-   }
-
-    void CentrifugalForceIntegrator::SetOmega(const mfem::Vector& omega) {
+    CentrifugalForceIntegrator::CentrifugalForceIntegrator(
+        const mapping::DomainMapper &map,
+        const mfem::Vector &omega
+    )
+        : m_map(map),
+          m_omega(3) {
         MFEM_ASSERT(omega.Size() == 3, "Omega vector must be 3D");
         m_omega = omega;
     }
 
+    void CentrifugalForceIntegrator::SetOmega(const mfem::Vector &omega) {
+        MFEM_ASSERT(omega.Size() == 3, "Omega vector must be 3D");
+        m_omega = omega;
+    }
+
+    void CentrifugalForceIntegrator::SetIntegrationRule(
+        const mfem::IntegrationRule &ir
+    ) {
+        m_ir = &ir;
+    }
+
     void CentrifugalForceIntegrator::AssembleElementVector(
         const mfem::Array<const mfem::FiniteElement *> &el,
         mfem::ElementTransformation &Tr,
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array<mfem::Vector *> &elvec
     ) {
-       if (utils::is_vacuum(Tr, elvec)) {
-           return;
-       }
+        if (utils::is_vacuum(Tr, elvec)) {
+            return;
+        }
 
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector& rho_dofs = *elfun[1];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::Vector& r_v = *elvec[0];
-        r_v = 0.0;
+        mfem::Vector &r_v                 = *elvec[0];
         r_v.SetSize(dof_v * dim);
+        r_v = 0.0;
         if (elvec[1]) {
             elvec[1]->SetSize(dof_rho);
             *elvec[1] = 0.0;
@@ -47,10 +55,15 @@ namespace mean_field::integrators {
         mfem::Vector x_phys(dim);
         mfem::Vector a(dim), b(dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        MFEM_VERIFY(
+            m_ir, "CentrifugalForceIntegrator must be configured with an "
+                  "integration rule before assembly. Call "
+                  "SetIntegrationRule first."
+        );
+        const mfem::IntegrationRule *ir = m_ir;
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -61,14 +74,14 @@ namespace mean_field::integrators {
             m_map.GetPhysicalPoint(Tr, ip, x_phys);
 
             // ω x r
-            a(0) = m_omega(1) * x_phys(2) - m_omega(2) * x_phys(1);
-            a(1) = m_omega(2) * x_phys(0) - m_omega(0) * x_phys(2);
-            a(2) = m_omega(0) * x_phys(1) - m_omega(1) * x_phys(0);
+            a(0)           = m_omega(1) * x_phys(2) - m_omega(2) * x_phys(1);
+            a(1)           = m_omega(2) * x_phys(0) - m_omega(0) * x_phys(2);
+            a(2)           = m_omega(0) * x_phys(1) - m_omega(1) * x_phys(0);
 
             // ω x (ω x r) [centrifugal acceleration]
-            b(0) = m_omega(1) * a(2) - m_omega(2) * a(1);
-            b(1) = m_omega(2) * a(0) - m_omega(0) * a(2);
-            b(2) = m_omega(0) * a(1) - m_omega(1) * a(0);
+            b(0)           = m_omega(1) * a(2) - m_omega(2) * a(1);
+            b(1)           = m_omega(2) * a(0) - m_omega(0) * a(2);
+            b(2)           = m_omega(0) * a(1) - m_omega(1) * a(0);
 
             double rho_val = 0.0;
             for (int i = 0; i < dof_rho; ++i) {
@@ -89,30 +102,39 @@ namespace mean_field::integrators {
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        if (utils::is_vacuum(Tr, elmats)) {
+            return;
+        }
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        mfem::DenseMatrix* dv_dv = elmats(0,0);
-        mfem::DenseMatrix* dv_drho = elmats(0,1);
+        mfem::DenseMatrix *dv_dv          = elmats(0, 0);
+        mfem::DenseMatrix *dv_drho        = elmats(0, 1);
 
-        if (dv_dv) *dv_dv = 0.0;
-        if (elmats(1, 0)) *elmats(1, 0) = 0.0;
-        if (elmats(1, 1)) *elmats(1, 1) = 0.0;
-        if (dv_drho) *dv_drho = 0.0;
-        if (!dv_drho) return;
+        if (dv_dv)
+            *dv_dv = 0.0;
+        if (elmats(1, 0))
+            *elmats(1, 0) = 0.0;
+        if (elmats(1, 1))
+            *elmats(1, 1) = 0.0;
+        if (dv_drho)
+            *dv_drho = 0.0;
+        if (!dv_drho)
+            return;
 
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
         mfem::Vector x_phys(dim);
         mfem::Vector a(dim), b(dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -137,10 +159,11 @@ namespace mean_field::integrators {
                 for (int c = 0; c < dim; ++c) {
                     const int row = i + c * dof_v;
                     for (int j = 0; j < dof_rho; ++j) {
-                        (*dv_drho)(row, j) += shape_v(i) * shape_rho(j) * b(c) * weight;
+                        (*dv_drho)(row, j) +=
+                            shape_v(i) * shape_rho(j) * b(c) * weight;
                     }
                 }
             }
         }
     }
-}
+} // namespace mean_field::integrators

libmeanfield/impl/integrators/coriolis.cpp

@@ -4,38 +4,43 @@ module;
 module mean_field;
 
 namespace mean_field::integrators {
-    CoriolisIntegrator::CoriolisIntegrator(const mapping::DomainMapper& map, const mfem::Vector& omega)
-    : m_map(map), m_omega(omega) {
+    CoriolisIntegrator::CoriolisIntegrator(
+        const mapping::DomainMapper &map,
+        const mfem::Vector &omega
+    )
+        : m_map(map),
+          m_omega(omega) {
         m_omega_mat.SetSize(3, 3);
-        m_omega_mat = 0.0;
+        m_omega_mat       = 0.0;
         m_omega_mat(0, 1) = -m_omega(2);
-        m_omega_mat(0, 2) =  m_omega(1);
-        m_omega_mat(1, 0) =  m_omega(2);
+        m_omega_mat(0, 2) = m_omega(1);
+        m_omega_mat(1, 0) = m_omega(2);
         m_omega_mat(1, 2) = -m_omega(0);
         m_omega_mat(2, 0) = -m_omega(1);
-        m_omega_mat(2, 1) =  m_omega(0);
+        m_omega_mat(2, 1) = m_omega(0);
     }
 
-    void CoriolisIntegrator::AssembleElementVector(const mfem::Array<const mfem::FiniteElement *> &el,
-                               mfem::ElementTransformation &Tr,
-                               const mfem::Array<const mfem::Vector *> &elfun,
-                               const mfem::Array<mfem::Vector *> &elvec
+    void CoriolisIntegrator::AssembleElementVector(
+        const mfem::Array<const mfem::FiniteElement *> &el,
+        mfem::ElementTransformation &Tr,
+        const mfem::Array<const mfem::Vector *> &elfun,
+        const mfem::Array<mfem::Vector *> &elvec
     ) {
         if (utils::is_vacuum(Tr, elvec)) {
             return;
         }
 
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector& v_dofs = *elfun[0];
-        const mfem::Vector& rho_dofs = *elfun[1];
+        const mfem::Vector &v_dofs        = *elfun[0];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::Vector& r_v = *elvec[0];
+        mfem::Vector &r_v                 = *elvec[0];
         r_v.SetSize(dof_v * dim);
         r_v = 0.0;
         if (elvec[1]) {
@@ -44,10 +49,11 @@ namespace mean_field::integrators {
         }
 
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -56,11 +62,14 @@ namespace mean_field::integrators {
             fe_rho->CalcShape(ip, shape_rho);
 
             double rho_val = 0.0;
-            for (int i = 0; i < dof_rho; ++i) rho_val += rho_dofs(i) * shape_rho(i);
+            for (int i = 0; i < dof_rho; ++i)
+                rho_val += rho_dofs(i) * shape_rho(i);
 
-            mfem::Vector v_val(dim); v_val = 0.0;
+            mfem::Vector v_val(dim);
+            v_val = 0.0;
             for (int i = 0; i < dof_v; ++i) {
-                for (int c = 0; c < dim; ++c) v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
+                for (int c = 0; c < dim; ++c)
+                    v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
             }
 
             mfem::Vector F_coriolis(dim);
@@ -69,39 +78,44 @@ namespace mean_field::integrators {
 
             for (int i = 0; i < dof_v; ++i) {
                 for (int c = 0; c < dim; ++c) {
-                    r_v(i + c * dof_v) += shape_v(i) * rho_val * F_coriolis(c) * weight;
+                    r_v(i + c * dof_v) +=
+                        shape_v(i) * rho_val * F_coriolis(c) * weight;
                 }
             }
         }
     }
 
-    void CoriolisIntegrator::AssembleElementGrad(const mfem::Array<const mfem::FiniteElement*> &el,
-                         mfem::ElementTransformation &Tr,
-                         const mfem::Array<const mfem::Vector *> &elfun,
-                         const mfem::Array2D<mfem::DenseMatrix *> &elmats
+    void CoriolisIntegrator::AssembleElementGrad(
+        const mfem::Array<const mfem::FiniteElement *> &el,
+        mfem::ElementTransformation &Tr,
+        const mfem::Array<const mfem::Vector *> &elfun,
+        const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
 
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector& v_dofs = *elfun[0];
-        const mfem::Vector& rho_dofs = *elfun[1];
+        const mfem::Vector &v_dofs        = *elfun[0];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::DenseMatrix* dv_dv = elmats(0, 0);
-        mfem::DenseMatrix* dv_drho = elmats(0, 1);
+        mfem::DenseMatrix *dv_dv          = elmats(0, 0);
+        mfem::DenseMatrix *dv_drho        = elmats(0, 1);
 
-        if (dv_dv) *dv_dv = 0.0;
-        if (dv_drho) *dv_drho = 0.0;
+        if (dv_dv)
+            *dv_dv = 0.0;
+        if (dv_drho)
+            *dv_drho = 0.0;
 
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -110,11 +124,14 @@ namespace mean_field::integrators {
             fe_rho->CalcShape(ip, shape_rho);
 
             double rho_val = 0.0;
-            for (int i = 0; i < dof_rho; ++i) rho_val += rho_dofs(i) * shape_rho(i);
+            for (int i = 0; i < dof_rho; ++i)
+                rho_val += rho_dofs(i) * shape_rho(i);
 
-            mfem::Vector v_val(dim); v_val = 0.0;
+            mfem::Vector v_val(dim);
+            v_val = 0.0;
             for (int i = 0; i < dof_v; ++i) {
-                for (int c = 0; c < dim; ++c) v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
+                for (int c = 0; c < dim; ++c)
+                    v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
             }
 
             mfem::Vector F_coriolis(dim);
@@ -124,12 +141,14 @@ namespace mean_field::integrators {
             if (dv_dv) {
                 for (int i = 0; i < dof_v; ++i) {
                     for (int c = 0; c < dim; ++c) {
-                        int row = i + c * dof_v;
+                        const int row = i + c * dof_v;
                         for (int j = 0; j < dof_v; ++j) {
                             for (int d = 0; d < dim; ++d) {
-                                int col = j + d * dof_v;
+                                int col         = j + d * dof_v;
                                 double coupling = m_omega_mat(c, d);
-                                (*dv_dv)(row, col) += shape_v(i) * shape_v(j) * 2.0 * rho_val * coupling * weight;
+                                (*dv_dv)(row, col) += shape_v(i) * shape_v(j) *
+                                                      2.0 * rho_val * coupling *
+                                                      weight;
                             }
                         }
                     }
@@ -142,11 +161,12 @@ namespace mean_field::integrators {
                         int row = i + c * dof_v;
                         for (int j = 0; j < dof_rho; ++j) {
                             int col = j;
-                            (*dv_drho)(row, col) += shape_v(i) * shape_rho(j) * F_coriolis(c) * weight;
+                            (*dv_drho)(row, col) += shape_v(i) * shape_rho(j) *
+                                                    F_coriolis(c) * weight;
                         }
                     }
                 }
             }
         }
     }
-}
+} // namespace mean_field::integrators

libmeanfield/impl/integrators/gravity.cpp

@@ -1,124 +1,341 @@
 module;
 #include <mfem.hpp>
 module mean_field;
+import :solver.fields;
+
+namespace {
+    using namespace mean_field;
+
+    constexpr int velocity_block =
+        solver::block_index(solver::FieldBlock::velocity);
+    constexpr int density_block =
+        solver::block_index(solver::FieldBlock::density);
+    constexpr int gravity_gradient_block =
+        solver::block_index(solver::FieldBlock::gravity_gradient);
+    constexpr int displacement_block =
+        solver::block_index(solver::FieldBlock::displacement);
+} // namespace
 
 namespace mean_field::integrators {
-    GravityForceIntegrator::GravityForceIntegrator(
-        const mapping::DomainMapper& map,
-        const mfem::GridFunction& phi
-    ): m_map(map), m_phi(&phi) {}
+    GravityMomentumIntegrator::GravityMomentumIntegrator(
+        const mapping::DomainMapper &map,
+        const GravityForceJacobianMode jacobian_mode
+    )
+        : m_map(map),
+          m_jacobian_mode(jacobian_mode) {
+    }
 
-    void GravityForceIntegrator::SetPotential(const mfem::GridFunction& phi) { m_phi = &phi; };
+    void GravityMomentumIntegrator::SetJacobianMode(
+        const GravityForceJacobianMode jacobian_mode
+    ) {
+        m_jacobian_mode = jacobian_mode;
+    }
 
-    void GravityForceIntegrator::AssembleElementVector(
+    void GravityMomentumIntegrator::SetIntegrationRule(
+        const mfem::IntegrationRule &integration_rule
+    ) {
+        m_integration_rule = &integration_rule;
+    }
+
+    GravityForceJacobianMode
+    GravityMomentumIntegrator::GetJacobianMode() const {
+        return m_jacobian_mode;
+    }
+
+    void GravityMomentumIntegrator::AssembleElementVector(
         const mfem::Array<const mfem::FiniteElement *> &el,
         mfem::ElementTransformation &Tr,
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array<mfem::Vector *> &elvec
     ) {
-
         if (utils::is_vacuum(Tr, elvec)) {
             return;
         }
 
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        MFEM_VERIFY(
+            m_integration_rule,
+            "GravityForceIntegrator must be configured with an "
+            "integration rule before assembly."
+        );
+        MFEM_VERIFY(
+            el.Size() > gravity_gradient_block,
+            "GravityForceIntegrator requires velocity, density, and "
+            "gravity-gradient finite elements."
+        );
+        MFEM_VERIFY(
+            elfun.Size() > gravity_gradient_block,
+            "GravityForceIntegrator requires velocity, density, and "
+            "gravity-gradient element states."
+        );
+        MFEM_VERIFY(
+            elvec.Size() > velocity_block && elvec[velocity_block],
+            "GravityForceIntegrator requires a velocity residual block."
+        );
+        MFEM_VERIFY(
+            el[velocity_block] && el[density_block] &&
+                el[gravity_gradient_block],
+            "GravityForceIntegrator received a null finite element."
+        );
+        MFEM_VERIFY(
+            elfun[density_block] && elfun[gravity_gradient_block],
+            "GravityForceIntegrator received a null element state."
+        );
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const mfem::FiniteElement *velocity_element = el[velocity_block];
+        const mfem::FiniteElement *density_element  = el[density_block];
+        const mfem::FiniteElement *gravity_gradient_element =
+            el[gravity_gradient_block];
 
-        const mfem::Vector& rho_dofs = *elfun[1];
+        const int velocity_dofs_count = velocity_element->GetDof();
+        const int density_dofs_count  = density_element->GetDof();
+        const int gravity_gradient_dofs_count =
+            gravity_gradient_element->GetDof();
+        const int dim                    = Tr.GetSpaceDim();
 
-        mfem::Vector& r_v = *elvec[0];
-        r_v.SetSize(dof_v * dim);
-        r_v = 0.0;
-        if (elvec[1]) {
-            elvec[1]->SetSize(dof_rho);
-            *elvec[1] = 0.0;
+        const mfem::Vector &density_dofs = *elfun[density_block];
+        const mfem::Vector &gravity_gradient_dofs =
+            *elfun[gravity_gradient_block];
+
+        MFEM_VERIFY(
+            density_dofs.Size() == density_dofs_count,
+            "GravityForceIntegrator received an incorrectly sized density "
+            "state."
+        );
+        MFEM_VERIFY(
+            gravity_gradient_dofs.Size() == gravity_gradient_dofs_count,
+            "GravityForceIntegrator received an incorrectly sized "
+            "gravity-gradient "
+            "state."
+        );
+
+        for (int block = 0; block < elvec.Size(); ++block) {
+            if (elvec[block]) {
+                *elvec[block] = 0.0;
+            }
         }
 
-        mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        mfem::Vector grad_phi_ref(dim), grad_phi_phys(dim), grad_phi_elem(dim);
+        mfem::Vector &velocity_residual = *elvec[velocity_block];
+        velocity_residual.SetSize(dim * velocity_dofs_count);
+        velocity_residual = 0.0;
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        if (elvec.Size() > density_block && elvec[density_block]) {
+            elvec[density_block]->SetSize(density_dofs_count);
+            *elvec[density_block] = 0.0;
+        }
 
-        for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
-            Tr.SetIntPoint(&ip);
+        if (elvec.Size() > gravity_gradient_block &&
+            elvec[gravity_gradient_block]) {
+            elvec[gravity_gradient_block]->SetSize(gravity_gradient_dofs_count);
+            *elvec[gravity_gradient_block] = 0.0;
+        }
 
-            auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
-            m_phi->GetGradient(Tr, grad_phi_elem);
-            mfem::DenseMatrix J_map(dim, dim), J_map_inv(dim, dim);
-            m_map.ComputeJacobian(Tr, J_map);
-            mfem::CalcInverse(J_map, J_map_inv);
-            J_map_inv.MultTranspose(grad_phi_elem, grad_phi_phys);
+        mfem::Vector velocity_shape(velocity_dofs_count);
+        mfem::Vector density_shape(density_dofs_count);
+        mfem::DenseMatrix gravity_gradient_shape(
+            gravity_gradient_dofs_count, dim
+        );
+        mfem::Vector gravity_gradient_element_value(dim);
+        mfem::Vector gravity_gradient_physical_value(dim);
 
-            fe_v->CalcShape(ip, shape_v);
-            fe_rho->CalcShape(ip, shape_rho);
+        const mfem::IntegrationRule &integration_rule = *m_integration_rule;
 
-            double rho_val = 0.0;
-            for (int i = 0; i < dof_rho; ++i) {
-                rho_val += rho_dofs(i) * shape_rho(i);
+        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
+            const mfem::IntegrationPoint &integration_point =
+                integration_rule.IntPoint(q);
+            Tr.SetIntPoint(&integration_point);
+
+            const mapping::VolumeQuadratureContext context =
+                m_map.GetQuadratureContext(Tr, integration_point);
+
+            velocity_element->CalcShape(integration_point, velocity_shape);
+            density_element->CalcShape(integration_point, density_shape);
+            gravity_gradient_element->CalcVShape(Tr, gravity_gradient_shape);
+
+            gravity_gradient_shape.MultTranspose(
+                gravity_gradient_dofs, gravity_gradient_element_value
+            );
+            context.J_inv.MultTranspose(
+                gravity_gradient_element_value, gravity_gradient_physical_value
+            );
+
+            double density_value = 0.0;
+            for (int i = 0; i < density_dofs_count; ++i) {
+                density_value += density_dofs(i) * density_shape(i);
             }
 
-            for (int i = 0;  i < dof_v; ++i) {
-                for (int c = 0; c < dim; ++c) {
-                    r_v(i + c * dof_v) += shape_v(i) * rho_val * grad_phi_phys(c) * weight;
+            for (int i = 0; i < velocity_dofs_count; ++i) {
+                for (int component = 0; component < dim; ++component) {
+                    velocity_residual(i + component * velocity_dofs_count) +=
+                        velocity_shape(i) * density_value *
+                        gravity_gradient_physical_value(component) *
+                        context.weight;
                 }
             }
         }
     }
 
-    void GravityForceIntegrator::AssembleElementGrad(
+    void GravityMomentumIntegrator::AssembleElementGrad(
         const mfem::Array<const mfem::FiniteElement *> &el,
         mfem::ElementTransformation &Tr,
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        if (utils::is_vacuum(Tr, elmats)) {
+            return;
+        }
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        MFEM_VERIFY(
+            m_integration_rule,
+            "GravityForceIntegrator must be configured with an "
+            "integration rule before assembly."
+        );
+        MFEM_VERIFY(
+            el.Size() > gravity_gradient_block,
+            "GravityForceIntegrator requires velocity, density, and "
+            "gravity-gradient finite elements."
+        );
+        MFEM_VERIFY(
+            elfun.Size() > gravity_gradient_block,
+            "GravityForceIntegrator requires velocity, density, and "
+            "gravity-gradient element states."
+        );
+        MFEM_VERIFY(
+            el[velocity_block] && el[density_block] &&
+                el[gravity_gradient_block],
+            "GravityForceIntegrator received a null finite element."
+        );
+        MFEM_VERIFY(
+            elfun[density_block] && elfun[gravity_gradient_block],
+            "GravityForceIntegrator received a null element state."
+        );
 
-        mfem::DenseMatrix* dv_dv = elmats(0, 0);
-        mfem::DenseMatrix* dv_drho = elmats(0, 1);
+        for (int row = 0; row < elmats.NumRows(); ++row) {
+            for (int column = 0; column < elmats.NumCols(); ++column) {
+                if (elmats(row, column)) {
+                    *elmats(row, column) = 0.0;
+                }
+            }
+        }
 
-        if (dv_dv) *dv_dv = 0.0;
-        if (dv_drho) *dv_drho = 0.0;
+        if (m_jacobian_mode == GravityForceJacobianMode::exact) {
+            MFEM_ABORT(
+                "Exact GravityForceIntegrator geometry Jacobian is unavailable "
+                "until "
+                "DomainMapper linearization is "
+                "implemented."
+            );
+        }
 
-        if (!dv_drho) return;
+        const mfem::FiniteElement *velocity_element = el[velocity_block];
+        const mfem::FiniteElement *density_element  = el[density_block];
+        const mfem::FiniteElement *gravity_gradient_element =
+            el[gravity_gradient_block];
 
-        mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        mfem::Vector grad_phi_ref(dim), grad_phi_phys(dim), grad_phi_elem(dim);
+        const int velocity_dofs_count = velocity_element->GetDof();
+        const int density_dofs_count  = density_element->GetDof();
+        const int gravity_gradient_dofs_count =
+            gravity_gradient_element->GetDof();
+        const int dim                    = Tr.GetSpaceDim();
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::Vector &density_dofs = *elfun[density_block];
+        const mfem::Vector &gravity_gradient_dofs =
+            *elfun[gravity_gradient_block];
 
-        for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
-            Tr.SetIntPoint(&ip);
+        MFEM_VERIFY(
+            density_dofs.Size() == density_dofs_count,
+            "GravityForceIntegrator received an incorrectly sized density "
+            "state."
+        );
+        MFEM_VERIFY(
+            gravity_gradient_dofs.Size() == gravity_gradient_dofs_count,
+            "GravityForceIntegrator received an incorrectly sized "
+            "gravity-gradient "
+            "state."
+        );
 
-            auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
-            m_phi->GetGradient(Tr, grad_phi_elem);
-            mfem::DenseMatrix J_map(dim, dim), J_map_inv(dim, dim);
-            m_map.ComputeJacobian(Tr, J_map);
-            mfem::CalcInverse(J_map, J_map_inv);
-            J_map_inv.MultTranspose(grad_phi_elem, grad_phi_phys);
+        mfem::DenseMatrix *dv_drho = elmats(velocity_block, density_block);
+        mfem::DenseMatrix *dv_dgrad_phi =
+            m_jacobian_mode == GravityForceJacobianMode::field_coupled
+                ? elmats(velocity_block, gravity_gradient_block)
+                : nullptr;
 
-            fe_v->CalcShape(ip, shape_v);
-            fe_rho->CalcShape(ip, shape_rho);
+        if (!dv_drho && !dv_dgrad_phi) {
+            return;
+        }
 
+        mfem::Vector velocity_shape(velocity_dofs_count);
+        mfem::Vector density_shape(density_dofs_count);
+        mfem::DenseMatrix gravity_gradient_shape(
+            gravity_gradient_dofs_count, dim
+        );
+        mfem::Vector gravity_gradient_element_value(dim);
+        mfem::Vector gravity_gradient_physical_value(dim);
+        mfem::Vector gravity_basis_element(dim);
+        mfem::Vector gravity_basis_physical(dim);
 
-            for (int i = 0; i < dof_v; ++i) {
-                for (int c = 0; c < dim; ++c) {
-                    const int row = i + c * dof_v;
-                    for (int j = 0; j < dof_rho; ++j) {
-                        (*dv_drho)(row, j) += shape_v(i) * shape_rho(j) * grad_phi_phys(c) * weight;
+        const mfem::IntegrationRule &integration_rule = *m_integration_rule;
+
+        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
+            const mfem::IntegrationPoint &integration_point =
+                integration_rule.IntPoint(q);
+            Tr.SetIntPoint(&integration_point);
+
+            const mapping::VolumeQuadratureContext context =
+                m_map.GetQuadratureContext(Tr, integration_point);
+
+            velocity_element->CalcShape(integration_point, velocity_shape);
+            density_element->CalcShape(integration_point, density_shape);
+            gravity_gradient_element->CalcVShape(Tr, gravity_gradient_shape);
+
+            gravity_gradient_shape.MultTranspose(
+                gravity_gradient_dofs, gravity_gradient_element_value
+            );
+            context.J_inv.MultTranspose(
+                gravity_gradient_element_value, gravity_gradient_physical_value
+            );
+
+            double density_value = 0.0;
+            for (int i = 0; i < density_dofs_count; ++i) {
+                density_value += density_dofs(i) * density_shape(i);
+            }
+
+            if (dv_drho) {
+                for (int i = 0; i < velocity_dofs_count; ++i) {
+                    for (int component = 0; component < dim; ++component) {
+                        const int row = i + component * velocity_dofs_count;
+
+                        for (int j = 0; j < density_dofs_count; ++j) {
+                            (*dv_drho)(row, j) +=
+                                velocity_shape(i) * density_shape(j) *
+                                gravity_gradient_physical_value(component) *
+                                context.weight;
+                        }
+                    }
+                }
+            }
+
+            if (dv_dgrad_phi) {
+                for (int j = 0; j < gravity_gradient_dofs_count; ++j) {
+                    for (int component = 0; component < dim; ++component) {
+                        gravity_basis_element(component) =
+                            gravity_gradient_shape(j, component);
+                    }
+
+                    context.J_inv.MultTranspose(
+                        gravity_basis_element, gravity_basis_physical
+                    );
+
+                    for (int i = 0; i < velocity_dofs_count; ++i) {
+                        for (int component = 0; component < dim; ++component) {
+                            const int row = i + component * velocity_dofs_count;
+                            (*dv_dgrad_phi)(row, j) +=
+                                velocity_shape(i) * density_value *
+                                gravity_basis_physical(component) *
+                                context.weight;
+                        }
                     }
                 }
             }
         }
     }
-}
+} // namespace mean_field::integrators

libmeanfield/impl/integrators/mass_continuity.cpp

@@ -4,7 +4,10 @@ module;
 module mean_field;
 
 namespace mean_field::integrators {
-    ContinuityVolumeIntegrator::ContinuityVolumeIntegrator(const mapping::DomainMapper& map) : m_map(map) {};
+    ContinuityVolumeIntegrator::ContinuityVolumeIntegrator(
+        const mapping::DomainMapper &map
+    )
+        : m_map(map) { };
 
     void ContinuityVolumeIntegrator::AssembleElementVector(
         const mfem::Array<const mfem::FiniteElement *> &el,
@@ -16,35 +19,37 @@ namespace mean_field::integrators {
             return;
         }
 
-        const mfem::FiniteElement *fe_v = el[0];
+        const mfem::FiniteElement *fe_v   = el[0];
         const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector v_dofs = *elfun[0];
-        const mfem::Vector rho_dofs = *elfun[1];
+        const mfem::Vector v_dofs         = *elfun[0];
+        const mfem::Vector rho_dofs       = *elfun[1];
 
-        void* data_rho_before = elvec[1] ? (void*)elvec[1]->GetData() : nullptr;
+        void *data_rho_before =
+            elvec[1] ? (void *)elvec[1]->GetData() : nullptr;
         int size_rho_before = elvec[1] ? elvec[1]->Size() : -1;
 
         if (elvec[0]) {
             elvec[0]->SetSize(dof_v * dim);
             *elvec[0] = 0.0;
         }
-        mfem::Vector& r_rho = *elvec[1];
+        mfem::Vector &r_rho = *elvec[1];
         r_rho.SetSize(dof_rho);
         r_rho = 0.0;
 
-
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        mfem::DenseMatrix dshape_rho_ref(dof_rho, dim), dshape_rho_phys(dof_rho, dim);
+        mfem::DenseMatrix dshape_rho_ref(dof_rho, dim),
+            dshape_rho_phys(dof_rho, dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -54,7 +59,8 @@ namespace mean_field::integrators {
             fe_rho->CalcDShape(ip, dshape_rho_ref);
             mfem::Mult(dshape_rho_ref, J_inv, dshape_rho_phys);
 
-            mfem::Vector v_val(dim); v_val = 0.0;
+            mfem::Vector v_val(dim);
+            v_val = 0.0;
             for (int i = 0; i < dof_v; ++i) {
                 for (int c = 0; c < dim; ++c) {
                     const int row = i + c * dof_v;
@@ -83,32 +89,38 @@ namespace mean_field::integrators {
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
 
-        const mfem::FiniteElement *fe_v = el[0];
+        const mfem::FiniteElement *fe_v   = el[0];
         const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector& v_dofs = *elfun[0];
-        const mfem::Vector& rho_dofs = *elfun[1];
+        const mfem::Vector &v_dofs        = *elfun[0];
+        const mfem::Vector &rho_dofs      = *elfun[1];
 
-        mfem::DenseMatrix* drho_dv = elmats(1, 0);
-        mfem::DenseMatrix* drho_drho = elmats(1, 1);
+        mfem::DenseMatrix *drho_dv        = elmats(1, 0);
+        mfem::DenseMatrix *drho_drho      = elmats(1, 1);
 
-        if (elmats(0, 0)) *elmats(0, 0) = 0.0;
-        if (elmats(0, 1)) *elmats(0, 1) = 0.0;
+        if (elmats(0, 0))
+            *elmats(0, 0) = 0.0;
+        if (elmats(0, 1))
+            *elmats(0, 1) = 0.0;
 
-        if (drho_dv) *drho_dv = 0.0;
-        if (drho_drho) *drho_drho = 0.0;
+        if (drho_dv)
+            *drho_dv = 0.0;
+        if (drho_drho)
+            *drho_drho = 0.0;
 
         mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
-        mfem::DenseMatrix dshape_rho_ref(dof_rho, dim), dshape_rho_phys(dof_rho, dim);
+        mfem::DenseMatrix dshape_rho_ref(dof_rho, dim),
+            dshape_rho_phys(dof_rho, dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -118,7 +130,8 @@ namespace mean_field::integrators {
             fe_rho->CalcDShape(ip, dshape_rho_ref);
             mfem::Mult(dshape_rho_ref, J_inv, dshape_rho_phys);
 
-            mfem::Vector v_val(dim); v_val = 0.0;
+            mfem::Vector v_val(dim);
+            v_val = 0.0;
             for (int i = 0; i < dof_v; ++i) {
                 for (int c = 0; c < dim; ++c) {
                     const int row = i + c * dof_v;
@@ -136,7 +149,8 @@ namespace mean_field::integrators {
                     for (int j = 0; j < dof_v; ++j) {
                         for (int d = 0; d < dim; ++d) {
                             const int col = j + d * dof_v;
-                            (*drho_dv)(i, col) -= dshape_rho_phys(i, d) * rho_val * shape_v(j) * weight;
+                            (*drho_dv)(i, col) -= dshape_rho_phys(i, d) *
+                                                  rho_val * shape_v(j) * weight;
                         }
                     }
                 }
@@ -149,15 +163,19 @@ namespace mean_field::integrators {
                         grad_psi_dot_v += dshape_rho_phys(i, c) * v_val(c);
                     }
                     for (int j = 0; j < dof_rho; ++j) {
-                        (*drho_drho)(i, j) -= grad_psi_dot_v * shape_rho(j) * weight;
-
+                        (*drho_drho)(i, j) -=
+                            grad_psi_dot_v * shape_rho(j) * weight;
                     }
                 }
             }
         }
     }
 
-    ContinuityFaceIntegrator::ContinuityFaceIntegrator(const mapping::DomainMapper& map): m_map(map) {}
+    ContinuityFaceIntegrator::ContinuityFaceIntegrator(
+        const mapping::DomainMapper &map
+    )
+        : m_map(map) {
+    }
 
     void ContinuityFaceIntegrator::AssembleFaceVector(
         const mfem::Array<const mfem::FiniteElement *> &el1,
@@ -166,19 +184,19 @@ namespace mean_field::integrators {
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array<mfem::Vector *> &elvect
     ) {
-        const mfem::FiniteElement *fe_v_minus = el1[0];
-        const mfem::FiniteElement *fe_v_plus = el2[0];
+        const mfem::FiniteElement *fe_v_minus   = el1[0];
+        const mfem::FiniteElement *fe_v_plus    = el2[0];
 
         const mfem::FiniteElement *fe_rho_minus = el1[1];
-        const mfem::FiniteElement *fe_rho_plus = el2[1];
+        const mfem::FiniteElement *fe_rho_plus  = el2[1];
 
-        const int dof_v_minus = fe_v_minus->GetDof();
-        const int dof_v_plus = fe_v_plus->GetDof();
+        const int dof_v_minus                   = fe_v_minus->GetDof();
+        const int dof_v_plus                    = fe_v_plus->GetDof();
 
-        const int dof_rho_minus = fe_rho_minus->GetDof();
-        const int dof_rho_plus = fe_rho_plus->GetDof();
+        const int dof_rho_minus                 = fe_rho_minus->GetDof();
+        const int dof_rho_plus                  = fe_rho_plus->GetDof();
 
-        const int dim = Tr.GetSpaceDim();
+        const int dim                           = Tr.GetSpaceDim();
 
         if (elvect[0]) {
             elvect[0]->SetSize(dim * dof_v_minus + dim * dof_v_plus);
@@ -186,10 +204,10 @@ namespace mean_field::integrators {
         }
         mfem::Vector &r_rho = *elvect[1];
         r_rho.SetSize(dof_rho_minus + dof_rho_plus);
-        r_rho = 0.0;
+        r_rho                = 0.0;
 
         const int attr_minus = Tr.Elem1->Attribute;
-        const int attr_plus = (Tr.Elem2 != nullptr) ? Tr.Elem2->Attribute : -1;
+        const int attr_plus  = (Tr.Elem2 != nullptr) ? Tr.Elem2->Attribute : -1;
         constexpr int VACUUM_ATTR = 3;
 
         if (attr_minus == VACUUM_ATTR || attr_plus == VACUUM_ATTR) {
@@ -200,30 +218,39 @@ namespace mean_field::integrators {
             return; // Boundary face,
         }
 
-        const mfem::Vector &v_dofs = *elfun[0]; // Size: dim * dof_v_minus + dim*dof_v_plus
-        const mfem::Vector &rho_dofs = *elfun[1]; // Size: dof_rho_minus + dof_rho_plus
+        const mfem::Vector &v_dofs =
+            *elfun[0]; // Size: dim * dof_v_minus + dim*dof_v_plus
+        const mfem::Vector &rho_dofs =
+            *elfun[1]; // Size: dof_rho_minus + dof_rho_plus
 
         // Helpers to auto offset to the correct point in the dof array
-        auto rho_minus_dof = [&](const int i) {return rho_dofs(i);};
-        auto rho_plus_dof = [&](const int i) {return rho_dofs(i + dof_rho_minus);};
-        auto v_minus_dof = [&](const int k, const int c) {return v_dofs(k + c * dof_v_minus);};
+        auto rho_minus_dof = [&](const int i) { return rho_dofs(i); };
+        auto rho_plus_dof  = [&](const int i) {
+            return rho_dofs(i + dof_rho_minus);
+        };
+        auto v_minus_dof = [&](const int k, const int c) {
+            return v_dofs(k + c * dof_v_minus);
+        };
 
-        const int p_v = fe_v_minus->GetOrder();
-        const int p_rho = fe_rho_minus->GetOrder();
+        const int p_v       = fe_v_minus->GetOrder();
+        const int p_rho     = fe_rho_minus->GetOrder();
         const int int_order = 2 * std::max(p_v, p_rho) + 1;
 
-        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(Tr.GetGeometryType(), int_order);
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(Tr.GetGeometryType(), int_order);
 
-        mfem::Vector shape_v_minus(dof_v_minus), shape_rho_minus(dof_rho_minus), shape_rho_plus(dof_rho_plus);
+        mfem::Vector shape_v_minus(dof_v_minus), shape_rho_minus(dof_rho_minus),
+            shape_rho_plus(dof_rho_plus);
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& face_ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &face_ip = ir->IntPoint(q);
 
             Tr.SetAllIntPoints(&face_ip);
             const mfem::IntegrationPoint &ip_minus = Tr.GetElement1IntPoint();
-            const mfem::IntegrationPoint &ip_plus = Tr.GetElement2IntPoint();
+            const mfem::IntegrationPoint &ip_plus  = Tr.GetElement2IntPoint();
 
-            auto [n_unit, ds, v_dot_n_scale] = m_map.GetFaceQuadratureContext(Tr, face_ip);
+            auto [n_unit, ds, v_dot_n_scale] =
+                m_map.GetFaceQuadratureContext(Tr, face_ip);
 
             fe_v_minus->CalcShape(ip_minus, shape_v_minus);
             fe_rho_minus->CalcShape(ip_minus, shape_rho_minus);
@@ -251,12 +278,14 @@ namespace mean_field::integrators {
             }
 
             // Upwind density
-            // I use the convention that the flow is positive when moving from minus to plus
+            // I use the convention that the flow is positive when moving from
+            // minus to plus
             const double rho_up = (u_n >= 0) ? rho_minus_val : rho_plus_val;
 
             const double flux_weighted = u_n * rho_up * ds;
 
-            // Note the normals need to be in opposite directions for these two fluxes
+            // Note the normals need to be in opposite directions for these two
+            // fluxes
             for (int i = 0; i < dof_rho_minus; ++i) {
                 r_rho(i) += shape_rho_minus(i) * flux_weighted;
             }
@@ -274,25 +303,26 @@ namespace mean_field::integrators {
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
-        const mfem::FiniteElement *fe_v_minus = el1[0];
-        const mfem::FiniteElement *fe_v_plus = el2[0];
+        const mfem::FiniteElement *fe_v_minus   = el1[0];
+        const mfem::FiniteElement *fe_v_plus    = el2[0];
         const mfem::FiniteElement *fe_rho_minus = el1[1];
-        const mfem::FiniteElement *fe_rho_plus = el2[1];
+        const mfem::FiniteElement *fe_rho_plus  = el2[1];
 
-        const int dof_v_minus = fe_v_minus->GetDof();
-        const int dof_v_plus = fe_v_plus->GetDof();
-        const int dof_rho_minus = fe_rho_minus->GetDof();
-        const int dof_rho_plus = fe_rho_plus->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v_minus                   = fe_v_minus->GetDof();
+        const int dof_v_plus                    = fe_v_plus->GetDof();
+        const int dof_rho_minus                 = fe_rho_minus->GetDof();
+        const int dof_rho_plus                  = fe_rho_plus->GetDof();
+        const int dim                           = Tr.GetSpaceDim();
 
-        const int N_v_total = dim * (dof_v_minus + dof_v_plus);
-        const int N_rho_total = dof_rho_minus + dof_rho_plus;
+        const int N_v_total    = dim * (dof_v_minus + dof_v_plus);
+        const int N_rho_total  = dof_rho_minus + dof_rho_plus;
 
-        auto size_and_zero_mat = [&](mfem::DenseMatrix* mat, const int r_size, const int c_size) {
-          if (mat) {
-              mat->SetSize(r_size, c_size);
-              *mat = 0.0;
-          }
+        auto size_and_zero_mat = [&](mfem::DenseMatrix *mat, const int r_size,
+                                     const int c_size) {
+            if (mat) {
+                mat->SetSize(r_size, c_size);
+                *mat = 0.0;
+            }
         };
 
         size_and_zero_mat(elmats(0, 0), N_v_total, N_v_total);
@@ -300,34 +330,41 @@ namespace mean_field::integrators {
         size_and_zero_mat(elmats(1, 0), N_rho_total, N_v_total);
         size_and_zero_mat(elmats(1, 1), N_rho_total, N_rho_total);
 
-        if (skip_face(Tr)) return;
+        if (skip_face(Tr))
+            return;
 
-        mfem::DenseMatrix *drho_dv = elmats(1, 0);
+        mfem::DenseMatrix *drho_dv   = elmats(1, 0);
         mfem::DenseMatrix *drho_drho = elmats(1, 1);
 
-        if (!drho_dv && !drho_drho) return;
+        if (!drho_dv && !drho_drho)
+            return;
 
-        const mfem::Vector &v_dofs = *elfun[0];
+        const mfem::Vector &v_dofs   = *elfun[0];
         const mfem::Vector &rho_dofs = *elfun[1];
 
-        const int int_order = 2 * std::max(fe_v_minus->GetOrder(), fe_rho_minus->GetOrder()) + 1;
-        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(Tr.GetGeometryType(), int_order);
+        const int int_order =
+            2 * std::max(fe_v_minus->GetOrder(), fe_rho_minus->GetOrder()) + 1;
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(Tr.GetGeometryType(), int_order);
 
-        mfem::Vector shape_v_minus(dof_v_minus), shape_rho_minus(dof_rho_minus), shape_rho_plus(dof_rho_plus);
+        mfem::Vector shape_v_minus(dof_v_minus), shape_rho_minus(dof_rho_minus),
+            shape_rho_plus(dof_rho_plus);
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& face_ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &face_ip = ir->IntPoint(q);
             Tr.SetAllIntPoints(&face_ip);
             const mfem::IntegrationPoint &ip_minus = Tr.GetElement1IntPoint();
-            const mfem::IntegrationPoint &ip_plus = Tr.GetElement2IntPoint();
+            const mfem::IntegrationPoint &ip_plus  = Tr.GetElement2IntPoint();
 
-            auto [n_unit, ds, v_dot_n_scale] = m_map.GetFaceQuadratureContext(Tr, face_ip);
+            auto [n_unit, ds, v_dot_n_scale] =
+                m_map.GetFaceQuadratureContext(Tr, face_ip);
 
             fe_v_minus->CalcShape(ip_minus, shape_v_minus);
             fe_rho_minus->CalcShape(ip_minus, shape_rho_minus);
             fe_rho_plus->CalcShape(ip_plus, shape_rho_plus);
 
-            const double u_n = compute_u_n(v_dofs, shape_v_minus, n_unit, dof_v_minus, dim);
+            const double u_n =
+                compute_u_n(v_dofs, shape_v_minus, n_unit, dof_v_minus, dim);
 
             double rho_minus_val = 0.0;
             for (int i = 0; i < dof_rho_minus; ++i) {
@@ -353,18 +390,21 @@ namespace mean_field::integrators {
                             (*drho_drho)(i, ip) += shape_rho_minus(i) * col_w;
                         }
                         for (int j = 0; j < dof_rho_plus; ++j) {
-                            (*drho_drho)(dof_rho_minus + j, ip) -= shape_rho_plus(j) * col_w;
+                            (*drho_drho)(dof_rho_minus + j, ip) -=
+                                shape_rho_plus(j) * col_w;
                         }
                     }
                 } else {
                     for (int jp = 0; jp < dof_rho_plus; ++jp) {
                         const double col_w = u_w * shape_rho_plus(jp);
-                        const int col_idx = dof_rho_minus + jp;
+                        const int col_idx  = dof_rho_minus + jp;
                         for (int i = 0; i < dof_rho_minus; ++i) {
-                            (*drho_drho)(i, col_idx) += shape_rho_minus(i) * col_w;
+                            (*drho_drho)(i, col_idx) +=
+                                shape_rho_minus(i) * col_w;
                         }
                         for (int j = 0; j < dof_rho_plus; ++j) {
-                            (*drho_drho)(dof_rho_minus + j, col_idx) -= shape_rho_plus(j) * col_w;
+                            (*drho_drho)(dof_rho_minus + j, col_idx) -=
+                                shape_rho_plus(j) * col_w;
                         }
                     }
                 }
@@ -375,13 +415,15 @@ namespace mean_field::integrators {
                 for (int c = 0; c < dim; ++c) {
                     const double n_c_rho_w = n_unit(c) * rho_w;
                     for (int k = 0; k < dof_v_minus; ++k) {
-                        const int col_idx = k + c * dof_v_minus;
+                        const int col_idx  = k + c * dof_v_minus;
                         const double col_w = n_c_rho_w * shape_v_minus(k);
                         for (int i = 0; i < dof_rho_minus; ++i) {
-                            (*drho_dv)(i, col_idx) += shape_rho_minus(i) * col_w;
+                            (*drho_dv)(i, col_idx) +=
+                                shape_rho_minus(i) * col_w;
                         }
                         for (int j = 0; j < dof_rho_plus; ++j) {
-                            (*drho_dv)(dof_rho_minus + j, col_idx) -= shape_rho_plus(j) * col_w;
+                            (*drho_dv)(dof_rho_minus + j, col_idx) -=
+                                shape_rho_plus(j) * col_w;
                         }
                     }
                 }
@@ -389,9 +431,11 @@ namespace mean_field::integrators {
         }
     }
 
-    bool ContinuityFaceIntegrator::skip_face(const mfem::FaceElementTransformations& Tr) {
+    bool ContinuityFaceIntegrator::skip_face(
+        const mfem::FaceElementTransformations &Tr
+    ) {
         constexpr int VACUUM_ATTR = 3;
-        const int attr_minus = Tr.Elem1->Attribute;
+        const int attr_minus      = Tr.Elem1->Attribute;
         const int attr_plus = (Tr.Elem2 != nullptr) ? Tr.Elem2->Attribute : -1;
         if (attr_minus == VACUUM_ATTR || attr_plus == VACUUM_ATTR) {
             return true; // No flux contribution for vacuum faces
@@ -402,7 +446,13 @@ namespace mean_field::integrators {
         return false;
     }
 
-    double ContinuityFaceIntegrator::compute_u_n(const mfem::Vector& v_dofs, const mfem::Vector& shape_v_minus, const mfem::Vector& n_unit, int dof_v_minus, int dim) {
+    double ContinuityFaceIntegrator::compute_u_n(
+        const mfem::Vector &v_dofs,
+        const mfem::Vector &shape_v_minus,
+        const mfem::Vector &n_unit,
+        int dof_v_minus,
+        int dim
+    ) {
         double u_n = 0.0;
         for (int c = 0; c < dim; ++c) {
             double v_c = 0.0;
@@ -413,5 +463,4 @@ namespace mean_field::integrators {
         }
         return u_n;
     }
-}
-
+} // namespace mean_field::integrators

libmeanfield/impl/integrators/viscosity.cpp

@@ -4,12 +4,18 @@ module mean_field;
 
 namespace mean_field::integrators {
     ViscosityIntegrator::ViscosityIntegrator(
-        const mapping::DomainMapper& map,
+        const mapping::DomainMapper &map,
         const double mu,
         const int quad_boost
-    ) : m_map(map), m_mu(mu), m_quad_boost(quad_boost) {}
+    )
+        : m_map(map),
+          m_mu(mu),
+          m_quad_boost(quad_boost) {
+    }
 
-    void ViscosityIntegrator::SetMu(const double mu) { m_mu = mu; }
+    void ViscosityIntegrator::SetMu(const double mu) {
+        m_mu = mu;
+    }
 
     void ViscosityIntegrator::AssembleElementVector(
         const mfem::Array<const mfem::FiniteElement *> &el,
@@ -21,19 +27,19 @@ namespace mean_field::integrators {
             return;
         }
 
-        void* data_before = (void*)elvec[0]->GetData();
-        int size_before = elvec[0]->Size();
+        void *data_before                 = (void *)elvec[0]->GetData();
+        int size_before                   = elvec[0]->Size();
 
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        const mfem::Vector& v_dofs = *elfun[0];
+        const mfem::Vector &v_dofs        = *elfun[0];
 
-        mfem::Vector& r_v = *elvec[0];
+        mfem::Vector &r_v                 = *elvec[0];
         r_v.SetSize(dof_v * dim);
         r_v = 0.0;
         if (elvec[1]) {
@@ -43,12 +49,13 @@ namespace mean_field::integrators {
 
         mfem::DenseMatrix dshape_v_ref(dof_v, dim), dshape_v_phys(dof_v, dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder() + m_quad_boost);
+        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(
+            fe_v->GetGeomType(), 2 * fe_v->GetOrder() + m_quad_boost
+        );
 
         for (int q = 0; q < ir->GetNPoints(); ++q) {
 
-
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -57,12 +64,13 @@ namespace mean_field::integrators {
             mfem::Mult(dshape_v_ref, J_inv, dshape_v_phys);
 
             // ∇v(c,j) = δj v_c
-            mfem::DenseMatrix grad_v(dim, dim); grad_v = 0.0;
+            mfem::DenseMatrix grad_v(dim, dim);
+            grad_v = 0.0;
             for (int n = 0; n < dof_v; ++n) {
                 for (int c = 0; c < dim; ++c) {
                     const double vn_c = v_dofs(n + c * dof_v);
                     for (int j = 0; j < dim; ++j) {
-                        grad_v( c, j) += vn_c * dshape_v_phys(n, j);
+                        grad_v(c, j) += vn_c * dshape_v_phys(n, j);
                     }
                 }
             }
@@ -80,7 +88,8 @@ namespace mean_field::integrators {
                     double acc = 0.0;
                     for (int j = 0; j < dim; ++j) {
                         double D_cj = grad_v(c, j) + grad_v(j, c);
-                        if (c == j) D_cj -= (2.0 / 3.0) * div_v;
+                        if (c == j)
+                            D_cj -= (2.0 / 3.0) * div_v;
                         acc += dshape_v_phys(i, j) * D_cj;
                     }
                     r_v(i + c * dof_v) += mu_w * acc;
@@ -95,27 +104,33 @@ namespace mean_field::integrators {
         const mfem::Array<const mfem::Vector *> &elfun,
         const mfem::Array2D<mfem::DenseMatrix *> &elmats
     ) {
-        const mfem::FiniteElement* fe_v = el[0];
-        const mfem::FiniteElement* fe_rho = el[1];
+        const mfem::FiniteElement *fe_v   = el[0];
+        const mfem::FiniteElement *fe_rho = el[1];
 
-        const int dof_v = fe_v->GetDof();
-        const int dof_rho = fe_rho->GetDof();
-        const int dim = Tr.GetSpaceDim();
+        const int dof_v                   = fe_v->GetDof();
+        const int dof_rho                 = fe_rho->GetDof();
+        const int dim                     = Tr.GetSpaceDim();
 
-        mfem::DenseMatrix* dv_dv = elmats(0, 0);
-        mfem::DenseMatrix* dv_drho = elmats(0, 1);
+        mfem::DenseMatrix *dv_dv          = elmats(0, 0);
+        mfem::DenseMatrix *dv_drho        = elmats(0, 1);
 
-        if (dv_drho) *dv_drho =0.0;
-        if (dv_dv) *dv_dv = 0.0;
-        if (elmats(1, 0)) *elmats(1, 0) = 0.0;
-        if (elmats(1, 1)) *elmats(1, 1) = 0.0;
-        if (!dv_dv) return;
+        if (dv_drho)
+            *dv_drho = 0.0;
+        if (dv_dv)
+            *dv_dv = 0.0;
+        if (elmats(1, 0))
+            *elmats(1, 0) = 0.0;
+        if (elmats(1, 1))
+            *elmats(1, 1) = 0.0;
+        if (!dv_dv)
+            return;
 
         mfem::DenseMatrix dshape_v_ref(dof_v, dim), dshape_v_phys(dof_v, dim);
 
-        const mfem::IntegrationRule* ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
+        const mfem::IntegrationRule *ir =
+            &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());
         for (int q = 0; q < ir->GetNPoints(); ++q) {
-            const mfem::IntegrationPoint& ip = ir->IntPoint(q);
+            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
             Tr.SetIntPoint(&ip);
 
             auto [J_inv, detJ, weight] = m_map.GetQuadratureContext(Tr, ip);
@@ -137,20 +152,20 @@ namespace mean_field::integrators {
                         for (int d = 0; d < dim; ++d) {
                             const int col = n + d * dof_v;
 
-                            double val = 0.0;
-                            if (c == d) val += dot_grad;
+                            double val    = 0.0;
+                            if (c == d)
+                                val += dot_grad;
 
                             val += dshape_v_phys(i, d) * dshape_v_phys(n, c);
 
-                            val -= (2.0 / 3.0) * dshape_v_phys(i, c) * dshape_v_phys(n, d);
+                            val -= (2.0 / 3.0) * dshape_v_phys(i, c) *
+                                   dshape_v_phys(n, d);
                             (*dv_dv)(row, col) += mu_w * val;
                         }
                     }
                 }
             }
         }
-
     }
 
-
-}
+} // namespace mean_field::integrators

libmeanfield/impl/mapping/coefficients.cpp

@@ -10,30 +10,38 @@ namespace mean_field::mapping {
     //////////////////////////////
     MappedScalarCoefficient::MappedScalarCoefficient(
         const DomainMapper &map,
-        mfem::Coefficient &coeff,
+        Coefficient &coeff,
         const COORDINATE_SPACE coord_space
-    ) : m_map(map),
-        m_coeff(coeff),
-        m_coord_space(coord_space) {};
+    )
+        : m_map(map),
+          m_coeff(coeff),
+          m_coord_space(coord_space) { };
 
-    double MappedScalarCoefficient::Eval(mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) {
+    double MappedScalarCoefficient::Eval(
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) {
         T.SetIntPoint(&ip);
         double f_val = 0.0;
 
         switch (m_coord_space) {
-            case COORDINATE_SPACE::PHYSICAL: {
-                f_val = eval_at_point(m_coeff, T, ip);
-                const double detJ = m_map.ComputeDetJ(T, ip);
-                return f_val * fabs(detJ);
-            }
-            case COORDINATE_SPACE::REFERENCE: {
-                f_val = m_coeff.Eval(T, ip);
-                return f_val;
-            }
+        case COORDINATE_SPACE::PHYSICAL: {
+            f_val             = eval_at_point(m_coeff, T, ip);
+            const double detJ = m_map.ComputeDetJ(T, ip);
+            return f_val * fabs(detJ);
+        }
+        case COORDINATE_SPACE::REFERENCE: {
+            f_val = m_coeff.Eval(T, ip);
+            return f_val;
+        }
         }
     }
 
-    double MappedScalarCoefficient::eval_at_point(mfem::Coefficient &c, mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) {
+    double MappedScalarCoefficient::eval_at_point(
+        Coefficient &c,
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) {
         return c.Eval(T, ip);
     }
 
@@ -45,22 +53,26 @@ namespace mean_field::mapping {
         const DomainMapper &map,
         mfem::Coefficient &sigma,
         const int dim
-    ) : mfem::MatrixCoefficient(dim),
-        m_map(map),
-        m_scalar(&sigma),
-        m_tensor(nullptr) {
-    };
+    )
+        : MatrixCoefficient(dim),
+          m_map(map),
+          m_scalar(&sigma),
+          m_tensor(nullptr) { };
 
     MappedDiffusionCoefficient::MappedDiffusionCoefficient(
         const DomainMapper &map,
-        mfem::MatrixCoefficient &sigma
-    ) : mfem::MatrixCoefficient(sigma.GetHeight()),
-        m_map(map),
-        m_scalar(nullptr),
-        m_tensor(&sigma) {
-    };
+        MatrixCoefficient &sigma
+    )
+        : MatrixCoefficient(sigma.GetHeight()),
+          m_map(map),
+          m_scalar(nullptr),
+          m_tensor(&sigma) { };
 
-    void MappedDiffusionCoefficient::Eval(mfem::DenseMatrix &K, mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) {
+    void MappedDiffusionCoefficient::Eval(
+        mfem::DenseMatrix &K,
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) {
         const int dim = height;
         T.SetIntPoint(&ip);
 
@@ -90,13 +102,17 @@ namespace mean_field::mapping {
     ///////////////////////////////
     MappedVectorCoefficient::MappedVectorCoefficient(
         const DomainMapper &map,
-        mfem::VectorCoefficient &coeff
-    ) : mfem::VectorCoefficient(coeff.GetVDim()),
-        m_map(map),
-        m_coeff(coeff) {
-    };
+        VectorCoefficient &coeff
+    )
+        : VectorCoefficient(coeff.GetVDim()),
+          m_map(map),
+          m_coeff(coeff) { };
 
-    void MappedVectorCoefficient::Eval(mfem::Vector &V, mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) {
+    void MappedVectorCoefficient::Eval(
+        mfem::Vector &V,
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) {
         const int dim = vdim;
         T.SetIntPoint(&ip);
 
@@ -118,24 +134,32 @@ namespace mean_field::mapping {
     PhysicalPositionFunctionCoefficient::PhysicalPositionFunctionCoefficient(
         const DomainMapper &map,
         Func f // std::function<double(const mfem::Vector&)>
-    ) : m_f(std::move(f)),
-        m_map(map) {};
+    )
+        : m_f(std::move(f)),
+          m_map(map) { };
 
-    double PhysicalPositionFunctionCoefficient::Eval(mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) {
+    double PhysicalPositionFunctionCoefficient::Eval(
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) {
         T.SetIntPoint(&ip);
         mfem::Vector x;
         m_map.GetPhysicalPoint(T, ip, x);
         return m_f(x);
     }
 
-    MappedHDivMassCoefficient::MappedHDivMassCoefficient(const DomainMapper& map, const int dim)
-    : mfem::MatrixCoefficient(dim),
-      m_map(map) {}
+    MappedHDivMassCoefficient::MappedHDivMassCoefficient(
+        const DomainMapper &map,
+        const int dim
+    )
+        : MatrixCoefficient(dim),
+          m_map(map) {
+    }
 
     void MappedHDivMassCoefficient::Eval(
-        mfem::DenseMatrix& matrix,
-        mfem::ElementTransformation& transformation,
-        const mfem::IntegrationPoint& integration_point
+        mfem::DenseMatrix &matrix,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point
     ) {
         transformation.SetIntPoint(&integration_point);
 
@@ -144,9 +168,12 @@ namespace mean_field::mapping {
 
         const double map_determinant = map_jacobian.Det();
 
-        MFEM_VERIFY(map_determinant > 0.0, "Domain mapping has a non-positive Jacobian determinant.");
+        MFEM_VERIFY(
+            map_determinant > 0.0,
+            "Domain mapping has a non-positive Jacobian determinant."
+        );
 
         mfem::MultAtB(map_jacobian, map_jacobian, matrix);
         matrix *= 1.0 / std::abs(map_determinant);
     }
-}
+} // namespace mean_field::mapping

libmeanfield/impl/mapping/compactification/kelvin.cpp

@@ -0,0 +1,266 @@
+module;
+
+#include <cmath>
+#include <mfem.hpp>
+#include <stdexcept>
+
+module mean_field;
+
+namespace {
+    bool vector_is_finite(const mfem::Vector &vector) {
+        for (int i = 0; i < vector.Size(); ++i) {
+            if (!std::isfinite(vector(i)))
+                return false;
+        }
+        return true;
+    }
+
+    bool matrix_is_finite(const mfem::DenseMatrix &matrix) {
+        for (int i = 0; i < matrix.Height(); ++i) {
+            for (int j = 0; j < matrix.Width(); ++j) {
+                if (!std::isfinite(matrix(i, j)))
+                    return false;
+            }
+        }
+        return true;
+    }
+} // namespace
+
+namespace mean_field::mapping::compactification {
+    KelvinCompactification::KelvinCompactification(
+        options::KelvinCompactificationOptions options
+    )
+        : m_options(options) {
+        if (!std::isfinite(m_options.r_star_ref) ||
+            !std::isfinite(m_options.r_inf_ref)) {
+            throw std::invalid_argument(
+                "Kelvin compactification radii must be finite."
+            );
+        }
+
+        if (m_options.r_star_ref <= 0.0 ||
+            m_options.r_inf_ref <= m_options.r_star_ref) {
+            throw std::invalid_argument(
+                "Kelvin compactification requires 0 < r_star_ref < r_inf_ref."
+            );
+        }
+
+        if (!std::isfinite(m_options.coordinate_tolerance) ||
+            m_options.coordinate_tolerance < 0.0 ||
+            m_options.coordinate_tolerance >= 1.0) {
+            throw std::invalid_argument(
+                "Kelvin compactification coordinate tolerance must be finite "
+                "and lie "
+                "in [0, 1)."
+            );
+        }
+    }
+
+    MappingStatus KelvinCompactification::ComputeRadialFactors(
+        const double compactification_coordinate,
+        RadialFactors &factors
+    ) const {
+        if (!std::isfinite(compactification_coordinate))
+            return MappingStatus::non_finite_input;
+
+        const double tolerance = m_options.coordinate_tolerance;
+
+        if (compactification_coordinate < -tolerance ||
+            compactification_coordinate > 1.0 + tolerance) {
+            return MappingStatus::outside_reference_domain;
+        }
+
+        double coordinate = compactification_coordinate;
+        if (coordinate < 0.0)
+            coordinate = 0.0;
+
+        if (coordinate >= 1.0 - tolerance) {
+            return MappingStatus::at_compactified_infinity;
+        }
+
+        const double radial_extent = m_options.r_inf_ref - m_options.r_star_ref;
+        const double computational_radius =
+            m_options.r_star_ref + coordinate * radial_extent;
+
+        if (!std::isfinite(computational_radius) ||
+            computational_radius <= 0.0) {
+            return MappingStatus::invalid_reference_radius;
+        }
+
+        const double one_minus_coordinate = 1.0 - coordinate;
+        const double denominator = computational_radius * one_minus_coordinate;
+
+        if (!std::isfinite(denominator) || denominator <= 0.0) {
+            return MappingStatus::non_finite_result;
+        }
+
+        const double scale = m_options.r_star_ref / denominator;
+        const double scale_derivative =
+            scale *
+            (1.0 / one_minus_coordinate - radial_extent / computational_radius);
+
+        if (!std::isfinite(scale) || !std::isfinite(scale_derivative)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        factors.coordinate           = coordinate;
+        factors.computational_radius = computational_radius;
+        factors.scale                = scale;
+        factors.scale_derivative     = scale_derivative;
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus KelvinCompactification::Evaluate(
+        const ExteriorMapInput &input,
+        ExteriorMapResult &result
+    ) const {
+        const int dimension = input.reference_position.Size();
+
+        if (dimension <= 0 || input.displaced_position.Size() != dimension ||
+            input.compactification_coordinate_gradient.Size() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (input.displacement_jacobian.Height() != dimension ||
+            input.displacement_jacobian.Width() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (!vector_is_finite(input.reference_position) ||
+            !vector_is_finite(input.displaced_position) ||
+            !vector_is_finite(input.compactification_coordinate_gradient) ||
+            !matrix_is_finite(input.displacement_jacobian)) {
+            return MappingStatus::non_finite_input;
+        }
+
+        RadialFactors factors;
+        const MappingStatus factor_status =
+            ComputeRadialFactors(input.compactification_coordinate, factors);
+        if (factor_status != MappingStatus::valid)
+            return factor_status;
+
+        result.physical_position.SetSize(dimension);
+        result.mapping_jacobian.SetSize(dimension, dimension);
+
+        for (int i = 0; i < dimension; ++i) {
+            result.physical_position(i) =
+                factors.scale * input.displaced_position(i);
+
+            for (int j = 0; j < dimension; ++j) {
+                const double scale_gradient =
+                    factors.scale_derivative *
+                    input.compactification_coordinate_gradient(j);
+                result.mapping_jacobian(i, j) =
+                    factors.scale * input.displacement_jacobian(i, j) +
+                    input.displaced_position(i) * scale_gradient;
+            }
+        }
+
+        if (!vector_is_finite(result.physical_position) ||
+            !matrix_is_finite(result.mapping_jacobian)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        const double mapping_determinant = result.mapping_jacobian.Det();
+
+        if (!std::isfinite(mapping_determinant))
+            return MappingStatus::non_finite_result;
+        if (mapping_determinant <= 0.0)
+            return MappingStatus::non_positive_determinant;
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus KelvinCompactification::EvaluateVariation(
+        const ExteriorMapInput &input,
+        const ExteriorMapResult &result,
+        const ExteriorMapDirection &direction,
+        ExteriorMapVariation &variation
+    ) const {
+        const int dimension = input.reference_position.Size();
+
+        if (dimension <= 0 || input.displaced_position.Size() != dimension ||
+            input.compactification_coordinate_gradient.Size() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (input.displacement_jacobian.Height() != dimension ||
+            input.displacement_jacobian.Width() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (result.physical_position.Size() != dimension ||
+            result.mapping_jacobian.Height() != dimension ||
+            result.mapping_jacobian.Width() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (direction.displaced_position_variation.Size() != dimension ||
+            direction.displacement_jacobian_variation.Height() != dimension ||
+            direction.displacement_jacobian_variation.Width() != dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (!vector_is_finite(input.reference_position) ||
+            !vector_is_finite(input.displaced_position) ||
+            !vector_is_finite(input.compactification_coordinate_gradient) ||
+            !matrix_is_finite(input.displacement_jacobian)) {
+            return MappingStatus::non_finite_input;
+        }
+
+        if (!vector_is_finite(result.physical_position) ||
+            !matrix_is_finite(result.mapping_jacobian) ||
+            !vector_is_finite(direction.displaced_position_variation) ||
+            !matrix_is_finite(direction.displacement_jacobian_variation)) {
+            return MappingStatus::non_finite_input;
+        }
+
+        RadialFactors factors;
+        const MappingStatus factor_status =
+            ComputeRadialFactors(input.compactification_coordinate, factors);
+        if (factor_status != MappingStatus::valid)
+            return factor_status;
+
+        variation.physical_position_variation.SetSize(dimension);
+        variation.mapping_jacobian_variation.SetSize(dimension, dimension);
+
+        for (int i = 0; i < dimension; ++i) {
+            variation.physical_position_variation(i) =
+                factors.scale * direction.displaced_position_variation(i);
+
+            for (int j = 0; j < dimension; ++j) {
+                const double scale_gradient =
+                    factors.scale_derivative *
+                    input.compactification_coordinate_gradient(j);
+                variation.mapping_jacobian_variation(i, j) =
+                    factors.scale *
+                        direction.displacement_jacobian_variation(i, j) +
+                    direction.displaced_position_variation(i) * scale_gradient;
+            }
+        }
+
+        if (!vector_is_finite(variation.physical_position_variation) ||
+            !matrix_is_finite(variation.mapping_jacobian_variation)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        return MappingStatus::valid;
+    }
+
+    std::string_view KelvinCompactification::GetName() const noexcept {
+        return "KelvinCompactification";
+    }
+
+    double KelvinCompactification::GetReferenceStellarRadius() const noexcept {
+        return m_options.r_star_ref;
+    }
+
+    double KelvinCompactification::GetReferenceInfinityRadius() const noexcept {
+        return m_options.r_inf_ref;
+    }
+
+    double KelvinCompactification::GetCoordinateTolerance() const noexcept {
+        return m_options.coordinate_tolerance;
+    }
+} // namespace mean_field::mapping::compactification

libmeanfield/impl/mapping/domain_mapper.cpp

@@ -2,26 +2,52 @@ module;
 #include <mfem.hpp>
 
 module mean_field;
+import :mapping.types;
+
+namespace {
+    double get_positive_map_jacobian(
+        const mean_field::mapping::DomainMapper &domain_mapper,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        mfem::DenseMatrix &map_jacobian
+    ) {
+        transformation.SetIntPoint(&integration_point);
+        domain_mapper.ComputeJacobian(transformation, map_jacobian);
+
+        const double map_determinant = map_jacobian.Det();
+        MFEM_VERIFY(
+            map_determinant > 0.0,
+            "Domain mapping has a non-positive Jacobian determinant."
+        );
+        return map_determinant;
+    }
+} // namespace
 
 namespace mean_field::mapping {
     DomainMapper::DomainMapper(
         const double r_star_ref,
         const double r_inf_ref
-    ) : m_d(nullptr),
-        m_r_star_ref(r_star_ref),
-        m_r_inf_ref(r_inf_ref) {
+    )
+        : m_d(nullptr),
+          m_r_star_ref(r_star_ref),
+          m_r_inf_ref(r_inf_ref) {
         InitAllScratchSpaces();
+        CalcIsIdentity() ? m_displacement_is_identity = true
+                         : m_displacement_is_identity = false;
     }
 
     DomainMapper::DomainMapper(
         const mfem::GridFunction &d,
         const double r_star_ref,
         const double r_inf_ref
-    ) : m_d(&d),
-        m_dim(d.FESpace()->GetMesh()->Dimension()),
-        m_r_star_ref(r_star_ref),
-        m_r_inf_ref(r_inf_ref) {
+    )
+        : m_d(&d),
+          m_dim(d.FESpace()->GetMesh()->Dimension()),
+          m_r_star_ref(r_star_ref),
+          m_r_inf_ref(r_inf_ref) {
         InitAllScratchSpaces();
+        CalcIsIdentity() ? m_displacement_is_identity = true
+                         : m_displacement_is_identity = false;
     }
 
     bool DomainMapper::is_vacuum(const mfem::ElementTransformation &T) const {
@@ -29,7 +55,9 @@ namespace mean_field::mapping {
             return T.Attribute == m_vacuum_attr;
         } else if (T.ElementType == mfem::ElementTransformation::BDR_ELEMENT) {
             return T.Attribute == m_vacuum_attr - 1;
-            // TODO: In a more robust code this should really be read from the stroid API to ensure that the vacuum boundary is really 1 - the vacuum material attribute
+            // TODO: In a more robust code this should really be read from the
+            // stroid API to ensure that the vacuum boundary is really 1 - the
+            // vacuum material attribute
         }
         return false;
     }
@@ -37,28 +65,69 @@ namespace mean_field::mapping {
     void DomainMapper::SetDisplacement(const mfem::GridFunction &d) {
         if (m_dim != d.FESpace()->GetMesh()->Dimension()) {
             const std::string err_msg = std::format(
-                "Dimension mismatch: DomainMapper is initialized for dimension {}, but provided displacement field has dimension {}.",
-                m_dim, d.FESpace()->GetMesh()->Dimension());
+                "Dimension mismatch: DomainMapper is initialized for dimension "
+                "{}, "
+                "but provided displacement field has "
+                "dimension {}.",
+                m_dim, d.FESpace()->GetMesh()->Dimension()
+            );
             throw std::invalid_argument(err_msg);
         }
         m_d = &d;
         InvalidateCache();
+
+        CalcIsIdentity() ? m_displacement_is_identity = true
+                         : m_displacement_is_identity = false;
     }
 
-    bool DomainMapper::IsIdentity() const {
-        return (m_d == nullptr);
+    bool DomainMapper::HasCompactification() const noexcept {
+        return std::isfinite(m_r_star_ref) && std::isfinite(m_r_inf_ref) &&
+               m_r_star_ref > 0.0 && m_r_inf_ref > m_r_star_ref &&
+               m_xi_clamp > 0.0 && m_xi_clamp < 1.0;
+    }
+
+    bool DomainMapper::HasDisplacementField() const noexcept {
+        return m_d != nullptr;
+    }
+
+    bool DomainMapper::CalcIsIdentity() const {
+        if (m_d == nullptr) {
+            return true;
+        }
+
+        const int local_identity = m_d->Normlinf() == 0.0 ? 1 : 0;
+
+        const auto *parallel_displacement =
+            dynamic_cast<const mfem::ParGridFunction *>(m_d);
+
+        if (parallel_displacement == nullptr) {
+            return local_identity == 1;
+        }
+
+        int global_identity = 0;
+        MPI_Allreduce(
+            &local_identity, &global_identity, 1, MPI_INT, MPI_MIN,
+            parallel_displacement->ParFESpace()->GetComm()
+        );
+
+        return global_identity == 1;
     }
 
     void DomainMapper::ResetDisplacement() {
         m_d = nullptr;
         InvalidateCache();
+        CalcIsIdentity() ? m_displacement_is_identity = true
+                         : m_displacement_is_identity = false;
     }
 
-    void DomainMapper::ComputeJacobian(mfem::ElementTransformation &T, mfem::DenseMatrix &J) const {
+    void DomainMapper::ComputeJacobian(
+        mfem::ElementTransformation &T,
+        mfem::DenseMatrix &J
+    ) const {
         J.SetSize(m_dim, m_dim);
-        J = 0.0;
+        J     = 0.0;
         m_J_D = 0.0;
-        if (IsIdentity()) {
+        if (!HasDisplacementField()) {
             for (int i = 0; i < m_dim; ++i) {
                 m_J_D(i, i) = 1.0; // Identity mapping
             }
@@ -76,7 +145,7 @@ namespace mean_field::mapping {
         if (is_vacuum(T)) {
             T.Transform(T.GetIntPoint(), m_x_ref);
 
-            if (IsIdentity()) {
+            if (!HasDisplacementField()) {
                 m_x_disp = m_x_ref;
             } else {
                 m_shape.SetSize(m_fe->GetDof());
@@ -91,15 +160,22 @@ namespace mean_field::mapping {
         }
     }
 
-    double DomainMapper::ComputeDetJ(mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) const {
-        if (IsIdentity() && !is_vacuum(T)) return 1.0; // If no mapping, the determinant of the Jacobian is 1
+    double DomainMapper::ComputeDetJ(
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) const {
+        if (!HasDisplacementField() && !is_vacuum(T))
+            return 1.0; // If no mapping, the determinant of the Jacobian is 1
         T.SetIntPoint(&ip);
         mfem::DenseMatrix J;
         ComputeJacobian(T, J);
         return J.Det();
     }
 
-    void DomainMapper::ComputeMappedDiffusionTensor(mfem::ElementTransformation &T, mfem::DenseMatrix &D) const {
+    void DomainMapper::ComputeMappedDiffusionTensor(
+        mfem::ElementTransformation &T,
+        mfem::DenseMatrix &D
+    ) const {
         ComputeJacobian(T, m_J_temp);
         const double detJ = m_J_temp.Det();
         mfem::CalcInverse(m_J_temp, m_JInv_temp);
@@ -108,41 +184,56 @@ namespace mean_field::mapping {
         D *= fabs(detJ);
     }
 
-    void DomainMapper::ComputeInverseJacobian(mfem::ElementTransformation &T, mfem::DenseMatrix &JInv) const {
+    void DomainMapper::ComputeInverseJacobian(
+        mfem::ElementTransformation &T,
+        mfem::DenseMatrix &JInv
+    ) const {
         ComputeJacobian(T, m_J_temp);
         JInv.SetSize(m_dim, m_dim);
         mfem::CalcInverse(m_J_temp, JInv);
     }
 
-    DomainMapper::VolumeQuadratureContext DomainMapper::GetQuadratureContext(mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip) const {
+    VolumeQuadratureContext DomainMapper::GetQuadratureContext(
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip
+    ) const {
         const int dim = T.GetSpaceDim();
         mfem::DenseMatrix J_map(dim, dim), J_inv(dim, dim);
         ComputeJacobian(T, J_map);
         mfem::DenseMatrix J_full(dim, dim);
         mfem::Mult(J_map, T.Jacobian(), J_full);
         mfem::CalcInverse(J_full, J_inv);
-        const double detJ = std::fabs(ComputeDetJ(T, ip));
+        const double detJ   = std::fabs(ComputeDetJ(T, ip));
         const double weight = ip.weight * T.Weight() * detJ;
         return {.J_inv = J_inv, .detJ = detJ, .weight = weight};
     }
 
-    DomainMapper::FaceQuadratureContext DomainMapper::GetFaceQuadratureContext(mfem::FaceElementTransformations &T, const mfem::IntegrationPoint &ip) const {
+    FaceQuadratureContext DomainMapper::GetFaceQuadratureContext(
+        mfem::FaceElementTransformations &T,
+        const mfem::IntegrationPoint &ip
+    ) const {
         const int dim = T.GetSpaceDim();
         T.SetAllIntPoints(&ip);
 
         mfem::Vector n_raw(dim);
         mfem::CalcOrtho(T.Jacobian(), n_raw);
 
-        if (IsIdentity()) {
+        if (!HasDisplacementField() && !is_vacuum(T)) {
             const double n_raw_mag = n_raw.Norml2();
             mfem::Vector n_unit(dim);
             n_unit = n_raw;
             n_unit /= n_raw_mag;
-            return FaceQuadratureContext{.normal=n_unit, .ds=ip.weight * n_raw_mag, .v_dot_n_scale = 1.0};
+            return FaceQuadratureContext{
+                .normal        = n_unit,
+                .ds            = ip.weight * n_raw_mag,
+                .v_dot_n_scale = 1.0
+            };
         }
 
-        // Nanson's Formula (https://en.wikiversity.org/wiki/Continuum_mechanics/Volume_change_and_area_change)
-        // Since the displacement field lives in H1 it should be irrelevant if we pick Elem1 or Elem2
+        // Nanson's Formula
+        // (https://en.wikiversity.org/wiki/Continuum_mechanics/Volume_change_and_area_change)
+        // Since the displacement field lives in H1 it should be irrelevant if
+        // we pick Elem1 or Elem2
         mfem::DenseMatrix J_map(dim, dim);
         ComputeJacobian(*T.Elem1, J_map);
         const double detJ_map = J_map.Det();
@@ -162,18 +253,21 @@ namespace mean_field::mapping {
         const double n_raw_mag = n_raw.Norml2();
 
         return FaceQuadratureContext{
-            .normal = n_unit,
-            .ds = ip.weight * n_raw_mag,
+            .normal        = n_unit,
+            .ds            = ip.weight * n_raw_mag,
             .v_dot_n_scale = n_phys_mag / n_raw_mag
         };
-
     }
 
-    void DomainMapper::GetPhysicalPoint(mfem::ElementTransformation &T, const mfem::IntegrationPoint &ip, mfem::Vector &x_phys) const {
+    void DomainMapper::GetPhysicalPoint(
+        mfem::ElementTransformation &T,
+        const mfem::IntegrationPoint &ip,
+        mfem::Vector &x_phys
+    ) const {
         x_phys.SetSize(m_dim);
         T.Transform(ip, m_x_ref);
 
-        if (IsIdentity()) {
+        if (!HasDisplacementField()) {
             x_phys = m_x_ref;
         } else {
             UpdateElementCache(T);
@@ -189,11 +283,91 @@ namespace mean_field::mapping {
         }
     }
 
-    void DomainMapper::GetVectorValue(const int i, const mfem::IntegrationPoint &ip, mfem::Vector &val) const {
+    void DomainMapper::GetVectorValue(
+        const int i,
+        const mfem::IntegrationPoint &ip,
+        mfem::Vector &val
+    ) const {
         m_d->GetVectorValue(i, ip, val);
     }
 
-    const mfem::GridFunction *DomainMapper::GetDisplacement() const { return m_d; }
+    void DomainMapper::MapHDivFluxToPhysical(
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        const mfem::Vector &reference_flux,
+        mfem::Vector &physical_flux
+    ) const {
+        MFEM_VERIFY(
+            reference_flux.Size() == m_dim,
+            "The reference H(div) flux has the wrong dimension."
+        );
+
+        mfem::DenseMatrix map_jacobian(m_dim, m_dim);
+        const double map_determinant = get_positive_map_jacobian(
+            *this, transformation, integration_point, map_jacobian
+        );
+
+        mfem::Vector mapped_flux(m_dim);
+        map_jacobian.Mult(reference_flux, mapped_flux);
+        mapped_flux /= map_determinant;
+
+        physical_flux = mapped_flux;
+    }
+
+    void DomainMapper::MapPhysicalFluxToHDivReference(
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        const mfem::Vector &physical_flux,
+        mfem::Vector &reference_flux
+    ) const {
+        MFEM_VERIFY(
+            physical_flux.Size() == m_dim,
+            "The physical flux has the wrong dimension."
+        );
+
+        mfem::DenseMatrix map_jacobian(m_dim, m_dim);
+        const double map_determinant = get_positive_map_jacobian(
+            *this, transformation, integration_point, map_jacobian
+        );
+
+        mfem::DenseMatrix inverse_map_jacobian(m_dim, m_dim);
+        mfem::CalcInverse(map_jacobian, inverse_map_jacobian);
+
+        mfem::Vector mapped_flux(m_dim);
+        inverse_map_jacobian.Mult(physical_flux, mapped_flux);
+        mapped_flux *= map_determinant;
+
+        reference_flux = mapped_flux;
+    }
+
+    void DomainMapper::MapReferenceGradientToPhysical(
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        const mfem::Vector &reference_gradient,
+        mfem::Vector &physical_gradient
+    ) const {
+        MFEM_VERIFY(
+            reference_gradient.Size() == m_dim,
+            "The reference gradient has the wrong dimension."
+        );
+
+        mfem::DenseMatrix map_jacobian(m_dim, m_dim);
+        get_positive_map_jacobian(
+            *this, transformation, integration_point, map_jacobian
+        );
+
+        mfem::DenseMatrix inverse_map_jacobian(m_dim, m_dim);
+        mfem::CalcInverse(map_jacobian, inverse_map_jacobian);
+
+        mfem::Vector mapped_gradient(m_dim);
+        inverse_map_jacobian.MultTranspose(reference_gradient, mapped_gradient);
+
+        physical_gradient = mapped_gradient;
+    }
+
+    const mfem::GridFunction *DomainMapper::GetDisplacement() const {
+        return m_d;
+    }
 
     double DomainMapper::GetPhysInfRadius() const {
         return 1.0 - m_xi_clamp;
@@ -208,11 +382,12 @@ namespace mean_field::mapping {
     }
 
     double DomainMapper::GetCacheHitRate() const {
-        return (static_cast<double>(m_cache_hits)) / static_cast<double>(m_cache_misses + m_cache_hits);
+        return (static_cast<double>(m_cache_hits)) /
+               static_cast<double>(m_cache_misses + m_cache_hits);
     }
 
     void DomainMapper::ResetCacheStats() const {
-        m_cache_hits = 0;
+        m_cache_hits   = 0;
         m_cache_misses = 0;
     }
 
@@ -225,28 +400,36 @@ namespace mean_field::mapping {
         m_d_val.SetSize(m_dim);
     }
 
-    void DomainMapper::ApplyKelvinMapping(const mfem::Vector &x_ref, mfem::Vector &x_phys) const {
+    void DomainMapper::ApplyKelvinMapping(
+        const mfem::Vector &x_ref,
+        mfem::Vector &x_phys
+    ) const {
         const double r_ref = x_ref.Norml2();
         double xi = (r_ref - m_r_star_ref) / (m_r_inf_ref - m_r_star_ref);
-        xi = std::clamp(xi, 0.0, m_xi_clamp);
+        xi        = std::clamp(xi, 0.0, m_xi_clamp);
         const double factor = m_r_star_ref / (r_ref * (1 - xi));
         x_phys *= factor;
     }
 
-    void DomainMapper::ComputeKelvinJacobian(const mfem::Vector &x_ref, const mfem::Vector &x_disp, const mfem::DenseMatrix &J_D,
-                               mfem::DenseMatrix &J) const {
-        const double r_ref = x_ref.Norml2();
+    void DomainMapper::ComputeKelvinJacobian(
+        const mfem::Vector &x_ref,
+        const mfem::Vector &x_disp,
+        const mfem::DenseMatrix &J_D,
+        mfem::DenseMatrix &J
+    ) const {
+        const double r_ref   = x_ref.Norml2();
         const double delta_R = m_r_inf_ref - m_r_star_ref;
 
-        double xi = (r_ref - m_r_star_ref) / delta_R;
-        xi = std::clamp(xi, 0.0, m_xi_clamp);
+        double xi            = (r_ref - m_r_star_ref) / delta_R;
+        xi                   = std::clamp(xi, 0.0, m_xi_clamp);
 
-        const double denom = 1.0 - xi;
+        const double denom   = 1.0 - xi;
 
-        const double k = m_r_star_ref / (r_ref * denom);
+        const double k       = m_r_star_ref / (r_ref * denom);
 
-        const double dk_dr = m_r_star_ref * ((1.0 / (delta_R * r_ref * denom * denom)) - (
-                                                 1.0 / (r_ref * r_ref * denom)));
+        const double dk_dr =
+            m_r_star_ref * ((1.0 / (delta_R * r_ref * denom * denom)) -
+                            (1.0 / (r_ref * r_ref * denom)));
 
         J.SetSize(m_dim, m_dim);
         const double outer_factor = dk_dr / r_ref;
@@ -262,13 +445,17 @@ namespace mean_field::mapping {
         m_cached_elem_id = -1;
     }
 
-    void DomainMapper::UpdateElementCache(const mfem::ElementTransformation &T) const {
-        if (IsIdentity()) return;
+    void DomainMapper::UpdateElementCache(
+        const mfem::ElementTransformation &T
+    ) const {
+        if (!HasDisplacementField())
+            return;
 
-        if (T.ElementNo != m_cached_elem_id || T.ElementType != m_cached_elem_type) {
+        if (T.ElementNo != m_cached_elem_id ||
+            T.ElementType != m_cached_elem_type) {
             m_cache_misses++;
-            m_cached_elem_id = T.ElementNo;
-            m_cached_elem_type = T.ElementType;
+            m_cached_elem_id                    = T.ElementNo;
+            m_cached_elem_type                  = T.ElementType;
 
             const mfem::FiniteElementSpace *fes = m_d->FESpace();
             mfem::Array<int> vdofs;
@@ -291,4 +478,4 @@ namespace mean_field::mapping {
             m_cache_hits++;
         }
     }
-}
+} // namespace mean_field::mapping

libmeanfield/impl/mapping/domain_mapper_new.cpp

@@ -0,0 +1,916 @@
+module;
+
+#include <cmath>
+#include <memory>
+#include <mfem.hpp>
+#include <stdexcept>
+#include <utility>
+
+module mean_field;
+import :mapping.types;
+import :mapping.compactification;
+import :utils.user;
+
+namespace {
+    bool vector_is_finite(const mfem::Vector &vector) {
+        for (int i = 0; i < vector.Size(); ++i) {
+            if (!std::isfinite(vector(i)))
+                return false;
+        }
+        return true;
+    }
+
+    bool matrix_is_finite(const mfem::DenseMatrix &matrix) {
+        for (int i = 0; i < matrix.Height(); ++i) {
+            for (int j = 0; j < matrix.Width(); ++j) {
+                if (!std::isfinite(matrix(i, j)))
+                    return false;
+            }
+        }
+        return true;
+    }
+} // namespace
+
+namespace mean_field::mapping {
+    ElementCompactificationData::ElementCompactificationData(
+        const mfem::FiniteElement &element,
+        const mfem::Vector &dofs
+    )
+        : m_element(&element),
+          m_dofs(dofs) {
+        if (element.GetRangeType() != mfem::FiniteElement::SCALAR) {
+            throw std::invalid_argument(
+                "Compactification coordinate requires a scalar finite element."
+            );
+        }
+
+        if (element.GetMapType() != mfem::FiniteElement::VALUE) {
+            throw std::invalid_argument(
+                "Compactification coordinate requires a value-mapped scalar "
+                "finite "
+                "element."
+            );
+        }
+
+        if (element.GetDerivType() != mfem::FiniteElement::GRAD) {
+            throw std::invalid_argument(
+                "Compactification coordinate finite element must provide a "
+                "gradient."
+            );
+        }
+
+        if (element.GetDof() <= 0) {
+            throw std::invalid_argument(
+                "Compactification coordinate finite element has no degrees of "
+                "freedom."
+            );
+        }
+
+        if (dofs.Size() != element.GetDof()) {
+            throw std::invalid_argument(
+                "Compactification coordinate DOF count does not match its "
+                "finite "
+                "element."
+            );
+        }
+    }
+
+    const mfem::FiniteElement &
+    ElementCompactificationData::GetElement() const noexcept {
+        return *m_element;
+    }
+
+    const mfem::Vector &ElementCompactificationData::GetDofs() const noexcept {
+        return m_dofs;
+    }
+
+    int ElementCompactificationData::GetDofCount() const noexcept {
+        return m_dofs.Size();
+    }
+
+    ElementDisplacementData::ElementDisplacementData(
+        const mfem::FiniteElement &element,
+        const mfem::Vector &displacement_dofs,
+        const mfem::Ordering::Type ordering
+    )
+        : m_element(&element),
+          m_dimension(0),
+          m_ordering(ordering) {
+        const int dof_count = element.GetDof();
+        if (dof_count <= 0)
+            throw std::invalid_argument(
+                "The displacement element must have at least one degree of "
+                "freedom."
+            );
+        if (displacement_dofs.Size() <= 0 ||
+            displacement_dofs.Size() % dof_count != 0) {
+            throw std::invalid_argument(
+                "The displacement vector size must be a positive multiple of "
+                "the "
+                "element degree-of-freedom count."
+            );
+        }
+
+        m_dimension = displacement_dofs.Size() / dof_count;
+        m_dof_matrix.SetSize(dof_count, m_dimension);
+
+        if (ordering == mfem::Ordering::byNODES) {
+            for (int component = 0; component < m_dimension; ++component) {
+                for (int i = 0; i < dof_count; ++i) {
+                    m_dof_matrix(i, component) =
+                        displacement_dofs(i + component * dof_count);
+                }
+            }
+        } else if (ordering == mfem::Ordering::byVDIM) {
+            for (int i = 0; i < dof_count; ++i) {
+                for (int component = 0; component < m_dimension; ++component) {
+                    m_dof_matrix(i, component) =
+                        displacement_dofs(component + i * m_dimension);
+                }
+            }
+        } else {
+            throw std::invalid_argument(
+                "Unsupported MFEM displacement ordering."
+            );
+        }
+    }
+
+    const mfem::FiniteElement &
+    ElementDisplacementData::GetElement() const noexcept {
+        return *m_element;
+    }
+
+    const mfem::DenseMatrix &
+    ElementDisplacementData::GetDofMatrix() const noexcept {
+        return m_dof_matrix;
+    }
+
+    int ElementDisplacementData::GetDimension() const noexcept {
+        return m_dimension;
+    }
+
+    int ElementDisplacementData::GetDofCount() const noexcept {
+        return m_element->GetDof();
+    }
+
+    mfem::Ordering::Type ElementDisplacementData::GetOrdering() const noexcept {
+        return m_ordering;
+    }
+
+    ElementDisplacementData ElementDisplacementDataFromElementVDofs(
+        const mfem::FiniteElement &element,
+        const mfem::Vector &displacement_dofs
+    ) {
+        return ElementDisplacementData(
+            element, displacement_dofs, mfem::Ordering::byNODES
+        );
+    }
+
+    DomainMapperStateless::Workspace::Workspace(const int dimension) {
+        SetDimension(dimension);
+    }
+
+    void DomainMapperStateless::Workspace::SetDimension(const int dimension) {
+        if (dimension <= 0) {
+            throw std::invalid_argument(
+                "Domain mapping workspace dimension must be positive."
+            );
+        }
+
+        m_dimension = dimension;
+
+        m_field_value.SetSize(dimension);
+        m_field_jacobian.SetSize(dimension, dimension);
+
+        m_compactification_point.coordinate = 0.0;
+        m_compactification_point.coordinate_gradient.SetSize(dimension);
+
+        m_reference_normal.SetSize(dimension);
+        m_mapped_normal.SetSize(dimension);
+        m_full_element_jacobian.SetSize(dimension, dimension);
+
+        m_vector_temp.SetSize(dimension);
+        m_matrix_temp_1.SetSize(dimension, dimension);
+        m_matrix_temp_2.SetSize(dimension, dimension);
+
+        m_exterior_result.physical_position.SetSize(dimension);
+        m_exterior_result.mapping_jacobian.SetSize(dimension, dimension);
+
+        m_exterior_variation.physical_position_variation.SetSize(dimension);
+        m_exterior_variation.mapping_jacobian_variation.SetSize(
+            dimension, dimension
+        );
+    }
+
+    int DomainMapperStateless::Workspace::GetDimension() const noexcept {
+        return m_dimension;
+    }
+
+    DomainMapperStateless::DomainMapperStateless(
+        const utils::DomainMapperStatelessOptions options,
+        std::unique_ptr<const compactification::ExteriorDomainMap> exterior_map
+    )
+        : m_options(options),
+          m_exterior_map(std::move(exterior_map)) {
+        if (m_options.dimension <= 0)
+            throw std::invalid_argument(
+                "The domain-mapping dimension must be positive."
+            );
+        if (m_options.vacuum_element_attribute <= 0)
+            throw std::invalid_argument(
+                "The vacuum element attribute must be positive."
+            );
+        if (!m_exterior_map)
+            throw std::invalid_argument(
+                "DomainMapperStateless requires an exterior-domain mapping."
+            );
+    }
+
+    bool DomainMapperStateless::IsCompactifiedElement(
+        const mfem::ElementTransformation &transformation
+    ) const noexcept {
+        return transformation.Attribute == m_options.vacuum_element_attribute;
+    }
+
+    int DomainMapperStateless::GetDimension() const noexcept {
+        return m_options.dimension;
+    }
+
+    int DomainMapperStateless::GetVacuumElementAttribute() const noexcept {
+        return m_options.vacuum_element_attribute;
+    }
+
+    const compactification::ExteriorDomainMap &
+    DomainMapperStateless::GetExteriorMap() const noexcept {
+        return *m_exterior_map;
+    }
+
+    void DomainMapperStateless::ValidateElementData(
+        const ElementMappingData &element_data
+    ) const {
+        const ElementDisplacementData &displacement = element_data.displacement;
+        const ElementCompactificationData &compactification =
+            element_data.compactification;
+
+        if (displacement.GetDimension() != m_options.dimension) {
+            throw std::invalid_argument(
+                "Displacement field dimension does not match the domain mapper "
+                "dimension."
+            );
+        }
+
+        if (displacement.GetElement().GetDim() != m_options.dimension) {
+            throw std::invalid_argument(
+                "Displacement finite element dimension does not match the "
+                "domain "
+                "mapper dimension."
+            );
+        }
+
+        if (compactification.GetElement().GetDim() != m_options.dimension) {
+            throw std::invalid_argument(
+                "Compactification finite element dimension does not match the "
+                "domain "
+                "mapper dimension."
+            );
+        }
+
+        if (displacement.GetElement().GetGeomType() !=
+            compactification.GetElement().GetGeomType()) {
+            throw std::invalid_argument(
+                "Displacement and compactification finite elements have "
+                "different "
+                "geometries."
+            );
+        }
+
+        if (compactification.GetElement().GetRangeType() !=
+            mfem::FiniteElement::SCALAR) {
+            throw std::invalid_argument(
+                "Compactification coordinate requires a scalar finite element."
+            );
+        }
+
+        if (compactification.GetElement().GetMapType() !=
+            mfem::FiniteElement::VALUE) {
+            throw std::invalid_argument(
+                "Compactification coordinate requires a value-mapped finite "
+                "element."
+            );
+        }
+
+        if (compactification.GetElement().GetDerivType() !=
+            mfem::FiniteElement::GRAD) {
+            throw std::invalid_argument(
+                "Compactification coordinate finite element does not provide a "
+                "gradient."
+            );
+        }
+
+        if (compactification.GetDofCount() !=
+            compactification.GetElement().GetDof()) {
+            throw std::invalid_argument(
+                "Compactification coordinate DOF count does not match its "
+                "finite "
+                "element."
+            );
+        }
+    }
+
+    MappingStatus DomainMapperStateless::EvaluateCompactificationCoordinate(
+        const ElementCompactificationData &compactification,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        Workspace &workspace,
+        CompactificationPointData &point_data
+    ) const {
+        const mfem::FiniteElement &element = compactification.GetElement();
+        const mfem::Vector &dofs           = compactification.GetDofs();
+        const int dof_count                = element.GetDof();
+
+        if (workspace.GetDimension() != m_options.dimension ||
+            transformation.GetSpaceDim() != m_options.dimension ||
+            element.GetDim() != m_options.dimension) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        if (dofs.Size() != dof_count) {
+            return MappingStatus::invalid_dimension;
+        }
+
+        for (int i = 0; i < dofs.Size(); ++i) {
+            if (!std::isfinite(dofs(i)))
+                return MappingStatus::non_finite_input;
+        }
+
+        transformation.SetIntPoint(&integration_point);
+
+        workspace.m_compactification_shape.SetSize(dof_count);
+        workspace.m_compactification_dshape.SetSize(
+            dof_count, m_options.dimension
+        );
+
+        element.CalcShape(
+            integration_point, workspace.m_compactification_shape
+        );
+        element.CalcPhysDShape(
+            transformation, workspace.m_compactification_dshape
+        );
+
+        point_data.coordinate = dofs * workspace.m_compactification_shape;
+        point_data.coordinate_gradient.SetSize(m_options.dimension);
+        workspace.m_compactification_dshape.MultTranspose(
+            dofs, point_data.coordinate_gradient
+        );
+
+        if (!std::isfinite(point_data.coordinate)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        for (int d = 0; d < point_data.coordinate_gradient.Size(); ++d) {
+            if (!std::isfinite(point_data.coordinate_gradient(d)))
+                return MappingStatus::non_finite_result;
+        }
+
+        return MappingStatus::valid;
+    }
+
+    void DomainMapperStateless::EvaluateField(
+        const ElementDisplacementData &field,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        Workspace &workspace,
+        mfem::Vector &value,
+        mfem::DenseMatrix &jacobian
+    ) const {
+        transformation.SetIntPoint(&integration_point);
+
+        const mfem::FiniteElement &element  = field.GetElement();
+        const mfem::DenseMatrix &dof_matrix = field.GetDofMatrix();
+
+        workspace.m_shape.SetSize(element.GetDof());
+        workspace.m_mesh_dshape.SetSize(element.GetDof(), m_options.dimension);
+
+        element.CalcShape(integration_point, workspace.m_shape);
+        element.CalcPhysDShape(transformation, workspace.m_mesh_dshape);
+
+        value.SetSize(m_options.dimension);
+        dof_matrix.MultTranspose(workspace.m_shape, value);
+
+        jacobian.SetSize(m_options.dimension, m_options.dimension);
+        mfem::MultAtB(dof_matrix, workspace.m_mesh_dshape, jacobian);
+    }
+
+    MappingStatus DomainMapperStateless::EvaluatePoint(
+        const ElementMappingData &element_data,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        Workspace &workspace,
+        MappingPointContext &context
+    ) const {
+        ValidateElementData(element_data);
+
+        if (workspace.GetDimension() != m_options.dimension)
+            throw std::invalid_argument(
+                "The mapping workspace has the wrong dimension."
+            );
+        if (transformation.GetSpaceDim() != m_options.dimension)
+            throw std::invalid_argument(
+                "The element transformation has the wrong spatial dimension."
+            );
+        if (transformation.GetGeometryType() !=
+            element_data.displacement.GetElement().GetGeomType())
+            throw std::invalid_argument(
+                "The element transformation geometry does not match the "
+                "supplied "
+                "element data."
+            );
+
+        transformation.SetIntPoint(&integration_point);
+
+        context.reference_position.SetSize(m_options.dimension);
+        transformation.Transform(integration_point, context.reference_position);
+
+        EvaluateField(
+            element_data.displacement, transformation, integration_point,
+            workspace, workspace.m_field_value, workspace.m_field_jacobian
+        );
+
+        if (!vector_is_finite(context.reference_position) ||
+            !vector_is_finite(workspace.m_field_value) ||
+            !matrix_is_finite(workspace.m_field_jacobian)) {
+            return MappingStatus::non_finite_input;
+        }
+
+        context.displaced_position.SetSize(m_options.dimension);
+        context.displaced_position = context.reference_position;
+        context.displaced_position += workspace.m_field_value;
+
+        context.displacement_jacobian.SetSize(
+            m_options.dimension, m_options.dimension
+        );
+        context.displacement_jacobian = workspace.m_field_jacobian;
+        for (int i = 0; i < m_options.dimension; ++i)
+            context.displacement_jacobian(i, i) += 1.0;
+
+        context.compactified = IsCompactifiedElement(transformation);
+
+        if (context.compactified) {
+            const MappingStatus coordinate_status =
+                EvaluateCompactificationCoordinate(
+                    element_data.compactification, transformation,
+                    integration_point, workspace,
+                    workspace.m_compactification_point
+                );
+
+            if (coordinate_status != MappingStatus::valid)
+                return coordinate_status;
+
+            const compactification::ExteriorMapInput exterior_input{
+                .reference_position    = context.reference_position,
+                .displaced_position    = context.displaced_position,
+                .displacement_jacobian = context.displacement_jacobian,
+                .compactification_coordinate =
+                    workspace.m_compactification_point.coordinate,
+                .compactification_coordinate_gradient =
+                    workspace.m_compactification_point.coordinate_gradient
+            };
+
+            const MappingStatus exterior_status = m_exterior_map->Evaluate(
+                exterior_input, workspace.m_exterior_result
+            );
+            if (exterior_status != MappingStatus::valid)
+                return exterior_status;
+
+            context.physical_position =
+                workspace.m_exterior_result.physical_position;
+            context.mapping_jacobian =
+                workspace.m_exterior_result.mapping_jacobian;
+        } else {
+            context.physical_position = context.displaced_position;
+            context.mapping_jacobian  = context.displacement_jacobian;
+        }
+
+        if (!vector_is_finite(context.physical_position) ||
+            !matrix_is_finite(context.mapping_jacobian))
+            return MappingStatus::non_finite_result;
+
+        context.mapping_determinant = context.mapping_jacobian.Det();
+        if (!std::isfinite(context.mapping_determinant))
+            return MappingStatus::non_finite_result;
+        if (context.mapping_determinant <= 0.0)
+            return MappingStatus::non_positive_determinant;
+
+        context.inverse_mapping_jacobian.SetSize(
+            m_options.dimension, m_options.dimension
+        );
+        mfem::CalcInverse(
+            context.mapping_jacobian, context.inverse_mapping_jacobian
+        );
+
+        if (!matrix_is_finite(context.inverse_mapping_jacobian))
+            return MappingStatus::non_finite_result;
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus DomainMapperStateless::EvaluateVolume(
+        const ElementMappingData &element_data,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        Workspace &workspace,
+        VolumeMappingContext &context
+    ) const {
+        const MappingStatus point_status = EvaluatePoint(
+            element_data, transformation, integration_point, workspace,
+            context.mapping
+        );
+        if (point_status != MappingStatus::valid)
+            return point_status;
+
+        transformation.SetIntPoint(&integration_point);
+        mfem::Mult(
+            context.mapping.mapping_jacobian, transformation.Jacobian(),
+            workspace.m_full_element_jacobian
+        );
+
+        context.quadrature.J_inv.SetSize(
+            m_options.dimension, m_options.dimension
+        );
+        mfem::CalcInverse(
+            workspace.m_full_element_jacobian, context.quadrature.J_inv
+        );
+
+        context.quadrature.detJ   = context.mapping.mapping_determinant;
+        context.quadrature.weight = integration_point.weight *
+                                    transformation.Weight() *
+                                    context.mapping.mapping_determinant;
+
+        if (!matrix_is_finite(context.quadrature.J_inv) ||
+            !std::isfinite(context.quadrature.weight))
+            return MappingStatus::non_finite_result;
+        if (context.quadrature.weight <= 0.0)
+            return MappingStatus::non_positive_determinant;
+
+        return MappingStatus::valid;
+    }
+
+    mfem::ElementTransformation &
+    DomainMapperStateless::SelectFaceElementTransformation(
+        mfem::FaceElementTransformations &transformation,
+        const FaceElementSide side
+    ) {
+        if (side == FaceElementSide::element_1) {
+            MFEM_VERIFY(
+                transformation.Elem1 != nullptr,
+                "The face does not have an element-1 transformation."
+            );
+            return *transformation.Elem1;
+        }
+
+        MFEM_VERIFY(
+            transformation.Elem2 != nullptr,
+            "The face does not have an element-2 transformation."
+        );
+        return *transformation.Elem2;
+    }
+
+    const mfem::IntegrationPoint &
+    DomainMapperStateless::SelectFaceElementIntegrationPoint(
+        mfem::FaceElementTransformations &transformation,
+        const FaceElementSide side
+    ) {
+        mfem::ElementTransformation &element_transformation =
+            SelectFaceElementTransformation(transformation, side);
+        return element_transformation.GetIntPoint();
+    }
+
+    MappingStatus DomainMapperStateless::EvaluateFace(
+        const ElementMappingData &element_data,
+        mfem::FaceElementTransformations &transformation,
+        const FaceElementSide side,
+        const mfem::IntegrationPoint &integration_point,
+        Workspace &workspace,
+        FaceMappingContext &context
+    ) const {
+        transformation.SetAllIntPoints(&integration_point);
+        mfem::ElementTransformation &element_transformation =
+            SelectFaceElementTransformation(transformation, side);
+        const mfem::IntegrationPoint &element_integration_point =
+            SelectFaceElementIntegrationPoint(transformation, side);
+
+        const MappingStatus point_status = EvaluatePoint(
+            element_data, element_transformation, element_integration_point,
+            workspace, context.mapping
+        );
+        if (point_status != MappingStatus::valid)
+            return point_status;
+
+        workspace.m_reference_normal.SetSize(m_options.dimension);
+        mfem::CalcOrtho(
+            transformation.Jacobian(), workspace.m_reference_normal
+        );
+        if (side == FaceElementSide::element_2)
+            workspace.m_reference_normal *= -1.0;
+
+        const double reference_normal_magnitude =
+            workspace.m_reference_normal.Norml2();
+        if (!std::isfinite(reference_normal_magnitude) ||
+            reference_normal_magnitude <= 0.0)
+            return MappingStatus::non_finite_result;
+
+        context.reference_normal.SetSize(m_options.dimension);
+        context.reference_normal = workspace.m_reference_normal;
+        context.reference_normal /= reference_normal_magnitude;
+
+        context.mapping.inverse_mapping_jacobian.MultTranspose(
+            workspace.m_reference_normal, workspace.m_mapped_normal
+        );
+        workspace.m_mapped_normal *= context.mapping.mapping_determinant;
+
+        const double mapped_normal_magnitude =
+            workspace.m_mapped_normal.Norml2();
+        if (!std::isfinite(mapped_normal_magnitude) ||
+            mapped_normal_magnitude <= 0.0)
+            return MappingStatus::non_finite_result;
+
+        context.quadrature.normal.SetSize(m_options.dimension);
+        context.quadrature.normal = workspace.m_mapped_normal;
+        context.quadrature.normal /= mapped_normal_magnitude;
+
+        context.reference_surface_weight =
+            integration_point.weight * reference_normal_magnitude;
+        context.physical_surface_weight =
+            integration_point.weight * mapped_normal_magnitude;
+
+        context.quadrature.ds = context.reference_surface_weight;
+        context.quadrature.v_dot_n_scale =
+            mapped_normal_magnitude / reference_normal_magnitude;
+
+        if (!vector_is_finite(context.quadrature.normal) ||
+            !std::isfinite(context.reference_surface_weight) ||
+            !std::isfinite(context.physical_surface_weight) ||
+            !std::isfinite(context.quadrature.v_dot_n_scale)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus DomainMapperStateless::EvaluatePointVariation(
+        const ElementMappingData &element_data,
+        const ElementDisplacementData &direction,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        const MappingPointContext &base_context,
+        Workspace &workspace,
+        MappingPointVariation &variation
+    ) const {
+        ValidateElementData(element_data);
+        const ElementMappingData direction_data{
+            .displacement     = direction,
+            .compactification = element_data.compactification
+        };
+        ValidateElementData(direction_data);
+
+        if (element_data.displacement.GetDofCount() != direction.GetDofCount())
+            throw std::invalid_argument(
+                "The displacement and direction elements have different "
+                "degree-of-freedom counts."
+            );
+        if (workspace.GetDimension() != m_options.dimension)
+            throw std::invalid_argument(
+                "The mapping workspace has the wrong dimension."
+            );
+        if (base_context.compactified != IsCompactifiedElement(transformation))
+            throw std::invalid_argument(
+                "The base mapping context does not match the current element "
+                "domain."
+            );
+
+        EvaluateField(
+            direction, transformation, integration_point, workspace,
+            workspace.m_field_value, workspace.m_field_jacobian
+        );
+
+        if (!vector_is_finite(workspace.m_field_value) ||
+            !matrix_is_finite(workspace.m_field_jacobian))
+            return MappingStatus::non_finite_input;
+
+        variation.displacement_variation          = workspace.m_field_value;
+        variation.displacement_jacobian_variation = workspace.m_field_jacobian;
+
+        if (base_context.compactified) {
+            const MappingStatus coordinate_status =
+                EvaluateCompactificationCoordinate(
+                    element_data.compactification, transformation,
+                    integration_point, workspace,
+                    workspace.m_compactification_point
+                );
+
+            if (coordinate_status != MappingStatus::valid)
+                return coordinate_status;
+
+            const compactification::ExteriorMapInput exterior_input{
+                .reference_position    = base_context.reference_position,
+                .displaced_position    = base_context.displaced_position,
+                .displacement_jacobian = base_context.displacement_jacobian,
+                .compactification_coordinate =
+                    workspace.m_compactification_point.coordinate,
+                .compactification_coordinate_gradient =
+                    workspace.m_compactification_point.coordinate_gradient
+            };
+
+            workspace.m_exterior_result.physical_position =
+                base_context.physical_position;
+            workspace.m_exterior_result.mapping_jacobian =
+                base_context.mapping_jacobian;
+
+            const compactification::ExteriorMapDirection exterior_direction{
+                .displaced_position_variation =
+                    variation.displacement_variation,
+                .displacement_jacobian_variation =
+                    variation.displacement_jacobian_variation
+            };
+
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const MappingStatus exterior_status =
+                m_exterior_map->EvaluateVariation(
+                    exterior_input, workspace.m_exterior_result,
+                    exterior_direction, workspace.m_exterior_variation
+                );
+
+            if (exterior_status != MappingStatus::valid) {
+                return exterior_status;
+            }
+
+            variation.physical_position_variation =
+                workspace.m_exterior_variation.physical_position_variation;
+            variation.mapping_jacobian_variation =
+                workspace.m_exterior_variation.mapping_jacobian_variation;
+        } else {
+            variation.physical_position_variation =
+                variation.displacement_variation;
+            variation.mapping_jacobian_variation =
+                variation.displacement_jacobian_variation;
+        }
+
+        mfem::Mult(
+            base_context.inverse_mapping_jacobian,
+            variation.mapping_jacobian_variation, workspace.m_matrix_temp_1
+        );
+
+        double trace = 0.0;
+        for (int i = 0; i < m_options.dimension; ++i)
+            trace += workspace.m_matrix_temp_1(i, i);
+        variation.mapping_determinant_variation =
+            base_context.mapping_determinant * trace;
+
+        variation.inverse_mapping_jacobian_variation.SetSize(
+            m_options.dimension, m_options.dimension
+        );
+        mfem::Mult(
+            workspace.m_matrix_temp_1, base_context.inverse_mapping_jacobian,
+            variation.inverse_mapping_jacobian_variation
+        );
+        variation.inverse_mapping_jacobian_variation *= -1.0;
+
+        if (!vector_is_finite(variation.physical_position_variation) ||
+            !matrix_is_finite(variation.mapping_jacobian_variation) ||
+            !matrix_is_finite(variation.inverse_mapping_jacobian_variation) ||
+            !std::isfinite(variation.mapping_determinant_variation)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus DomainMapperStateless::EvaluateVolumeVariation(
+        const ElementMappingData &element_data,
+        const ElementDisplacementData &direction,
+        mfem::ElementTransformation &transformation,
+        const mfem::IntegrationPoint &integration_point,
+        const VolumeMappingContext &base_context,
+        Workspace &workspace,
+        VolumeMappingVariation &variation
+    ) const {
+        const MappingStatus point_status = EvaluatePointVariation(
+            element_data, direction, transformation, integration_point,
+            base_context.mapping, workspace, variation.mapping
+        );
+        if (point_status != MappingStatus::valid)
+            return point_status;
+
+        transformation.SetIntPoint(&integration_point);
+        mfem::Mult(
+            variation.mapping.mapping_jacobian_variation,
+            transformation.Jacobian(), workspace.m_full_element_jacobian
+        );
+        mfem::Mult(
+            base_context.quadrature.J_inv, workspace.m_full_element_jacobian,
+            workspace.m_matrix_temp_1
+        );
+
+        variation.inverse_element_jacobian_variation.SetSize(
+            m_options.dimension, m_options.dimension
+        );
+        mfem::Mult(
+            workspace.m_matrix_temp_1, base_context.quadrature.J_inv,
+            variation.inverse_element_jacobian_variation
+        );
+        variation.inverse_element_jacobian_variation *= -1.0;
+
+        variation.weight_variation =
+            integration_point.weight * transformation.Weight() *
+            variation.mapping.mapping_determinant_variation;
+
+        if (!matrix_is_finite(variation.inverse_element_jacobian_variation) ||
+            !std::isfinite(variation.weight_variation))
+            return MappingStatus::non_finite_result;
+
+        return MappingStatus::valid;
+    }
+
+    MappingStatus DomainMapperStateless::EvaluateFaceVariation(
+        const ElementMappingData &element_data,
+        const ElementDisplacementData &direction,
+        mfem::FaceElementTransformations &transformation,
+        const FaceElementSide side,
+        const mfem::IntegrationPoint &integration_point,
+        const FaceMappingContext &base_context,
+        Workspace &workspace,
+        FaceMappingVariation &variation
+    ) const {
+        transformation.SetAllIntPoints(&integration_point);
+        mfem::ElementTransformation &element_transformation =
+            SelectFaceElementTransformation(transformation, side);
+        const mfem::IntegrationPoint &element_integration_point =
+            SelectFaceElementIntegrationPoint(transformation, side);
+
+        const MappingStatus point_status = EvaluatePointVariation(
+            element_data, direction, element_transformation,
+            element_integration_point, base_context.mapping, workspace,
+            variation.mapping
+        );
+        if (point_status != MappingStatus::valid)
+            return point_status;
+
+        workspace.m_reference_normal.SetSize(m_options.dimension);
+        mfem::CalcOrtho(
+            transformation.Jacobian(), workspace.m_reference_normal
+        );
+        if (side == FaceElementSide::element_2)
+            workspace.m_reference_normal *= -1.0;
+
+        const double reference_normal_magnitude =
+            workspace.m_reference_normal.Norml2();
+        if (!std::isfinite(reference_normal_magnitude) ||
+            reference_normal_magnitude <= 0.0)
+            return MappingStatus::non_finite_result;
+
+        base_context.mapping.inverse_mapping_jacobian.MultTranspose(
+            workspace.m_reference_normal, workspace.m_vector_temp
+        );
+        workspace.m_mapped_normal = workspace.m_vector_temp;
+        workspace.m_mapped_normal *= base_context.mapping.mapping_determinant;
+
+        variation.physical_normal_variation.SetSize(m_options.dimension);
+        variation.mapping.inverse_mapping_jacobian_variation.MultTranspose(
+            workspace.m_reference_normal, variation.physical_normal_variation
+        );
+        variation.physical_normal_variation *=
+            base_context.mapping.mapping_determinant;
+        variation.physical_normal_variation.Add(
+            variation.mapping.mapping_determinant_variation,
+            workspace.m_vector_temp
+        );
+
+        const double mapped_normal_magnitude =
+            workspace.m_mapped_normal.Norml2();
+        if (!std::isfinite(mapped_normal_magnitude) ||
+            mapped_normal_magnitude <= 0.0)
+            return MappingStatus::non_finite_result;
+
+        const double mapped_normal_magnitude_variation =
+            base_context.quadrature.normal *
+            variation.physical_normal_variation;
+
+        variation.physical_normal_variation.Add(
+            -mapped_normal_magnitude_variation, base_context.quadrature.normal
+        );
+        variation.physical_normal_variation /= mapped_normal_magnitude;
+
+        variation.physical_surface_weight_variation =
+            integration_point.weight * mapped_normal_magnitude_variation;
+        variation.normal_flux_scale_variation =
+            mapped_normal_magnitude_variation / reference_normal_magnitude;
+
+        if (!vector_is_finite(variation.physical_normal_variation) ||
+            !std::isfinite(variation.physical_surface_weight_variation) ||
+            !std::isfinite(variation.normal_flux_scale_variation)) {
+            return MappingStatus::non_finite_result;
+        }
+
+        return MappingStatus::valid;
+    }
+} // namespace mean_field::mapping

libmeanfield/impl/mapping/transformations.cpp

@@ -0,0 +1,276 @@
+module;
+#include <mfem.hpp>
+
+module mean_field;
+import :mapping.types;
+
+namespace mean_field::mapping {
+    void MapHDivFluxToPhysical(
+        const MappingPointContext &context,
+        const mfem::Vector &reference_flux,
+        mfem::Vector &physical_flux
+    ) {
+        MFEM_VERIFY(
+            reference_flux.Size() == context.mapping_jacobian.Width(),
+            "The reference H(div) flux has the wrong dimension."
+        );
+
+        physical_flux.SetSize(reference_flux.Size());
+        context.mapping_jacobian.Mult(reference_flux, physical_flux);
+        physical_flux /= context.mapping_determinant;
+    }
+
+    void MapPhysicalFluxToHDivReference(
+        const MappingPointContext &context,
+        const mfem::Vector &physical_flux,
+        mfem::Vector &reference_flux
+    ) {
+        MFEM_VERIFY(
+            physical_flux.Size() == context.inverse_mapping_jacobian.Width(),
+            "The physical H(div) flux has the wrong dimension."
+        );
+
+        reference_flux.SetSize(physical_flux.Size());
+        context.inverse_mapping_jacobian.Mult(physical_flux, reference_flux);
+        reference_flux *= context.mapping_determinant;
+    }
+
+    void MapReferenceGradientToPhysical(
+        const MappingPointContext &context,
+        const mfem::Vector &reference_gradient,
+        mfem::Vector &physical_gradient
+    ) {
+        MFEM_VERIFY(
+            reference_gradient.Size() ==
+                context.inverse_mapping_jacobian.Height(),
+            "The reference scalar gradient has the wrong dimension."
+        );
+
+        physical_gradient.SetSize(reference_gradient.Size());
+        context.inverse_mapping_jacobian.MultTranspose(
+            reference_gradient, physical_gradient
+        );
+    }
+
+    void MapPhysicalGradientToReference(
+        const MappingPointContext &context,
+        const mfem::Vector &physical_gradient,
+        mfem::Vector &reference_gradient
+    ) {
+        MFEM_VERIFY(
+            physical_gradient.Size() == context.mapping_jacobian.Height(),
+            "The physical scalar gradient has the wrong dimension."
+        );
+
+        reference_gradient.SetSize(physical_gradient.Size());
+        context.mapping_jacobian.MultTranspose(
+            physical_gradient, reference_gradient
+        );
+    }
+
+    void MapReferenceVectorGradientToPhysical(
+        const MappingPointContext &context,
+        const mfem::DenseMatrix &reference_gradient,
+        mfem::DenseMatrix &physical_gradient
+    ) {
+        MFEM_VERIFY(
+            reference_gradient.Width() ==
+                context.inverse_mapping_jacobian.Height(),
+            "The reference vector gradient has the wrong dimension."
+        );
+
+        physical_gradient.SetSize(
+            reference_gradient.Height(),
+            context.inverse_mapping_jacobian.Width()
+        );
+        mfem::Mult(
+            reference_gradient, context.inverse_mapping_jacobian,
+            physical_gradient
+        );
+    }
+
+    void MapPhysicalVectorGradientToReference(
+        const MappingPointContext &context,
+        const mfem::DenseMatrix &physical_gradient,
+        mfem::DenseMatrix &reference_gradient
+    ) {
+        MFEM_VERIFY(
+            physical_gradient.Width() == context.mapping_jacobian.Height(),
+            "The physical vector gradient has the wrong dimension."
+        );
+
+        reference_gradient.SetSize(
+            physical_gradient.Height(), context.mapping_jacobian.Width()
+        );
+        mfem::Mult(
+            physical_gradient, context.mapping_jacobian, reference_gradient
+        );
+    }
+
+    double MapHDivDivergenceToPhysical(
+        const MappingPointContext &context,
+        const double reference_divergence
+    ) {
+        return reference_divergence / context.mapping_determinant;
+    }
+
+    void ComputeHDivMassTensor(
+        const MappingPointContext &context,
+        mfem::DenseMatrix &mass_tensor
+    ) {
+        const int dimension = context.mapping_jacobian.Height();
+
+        MFEM_VERIFY(
+            context.mapping_jacobian.Width() == dimension,
+            "The mapping Jacobian must be square."
+        );
+        MFEM_VERIFY(
+            context.mapping_determinant > 0.0,
+            "The mapping determinant must be positive."
+        );
+
+        mass_tensor.SetSize(dimension, dimension);
+        mfem::MultAtB(
+            context.mapping_jacobian, context.mapping_jacobian, mass_tensor
+        );
+        mass_tensor *= 1 / context.mapping_determinant;
+    }
+
+    void ComputeScalarDiffusionTensor(
+        const MappingPointContext &context,
+        mfem::DenseMatrix &diffusion_tensor
+    ) {
+        const int dimension = context.inverse_mapping_jacobian.Height();
+
+        MFEM_VERIFY(
+            context.inverse_mapping_jacobian.Width() == dimension,
+            "The inverse mapping Jacobian must be square."
+        );
+        MFEM_VERIFY(
+            context.mapping_determinant > 0.0,
+            "The mapping determinant must be positive."
+        );
+
+        diffusion_tensor.SetSize(dimension, dimension);
+        mfem::MultABt(
+            context.inverse_mapping_jacobian, context.inverse_mapping_jacobian,
+            diffusion_tensor
+        );
+        diffusion_tensor *= context.mapping_determinant;
+    }
+
+    void MapHCurlFieldToPhysical(
+        const MappingPointContext &context,
+        const mfem::Vector &reference_field,
+        mfem::Vector &physical_field
+    ) {
+        MFEM_VERIFY(
+            reference_field.Size() == context.inverse_mapping_jacobian.Height(),
+            "The reference H(curl) field has the wrong dimension."
+        );
+
+        physical_field.SetSize(reference_field.Size());
+        context.inverse_mapping_jacobian.MultTranspose(
+            reference_field, physical_field
+        );
+    }
+
+    void MapPhysicalFieldToHCurlReference(
+        const MappingPointContext &context,
+        const mfem::Vector &physical_field,
+        mfem::Vector &reference_field
+    ) {
+        MFEM_VERIFY(
+            physical_field.Size() == context.mapping_jacobian.Height(),
+            "The physical H(curl) field has the wrong dimension."
+        );
+
+        reference_field.SetSize(physical_field.Size());
+        context.mapping_jacobian.MultTranspose(physical_field, reference_field);
+    }
+
+    void MapHCurlCurlToPhysical(
+        const MappingPointContext &context,
+        const mfem::Vector &reference_curl,
+        mfem::Vector &physical_curl
+    ) {
+        MFEM_VERIFY(
+            reference_curl.Size() == context.mapping_jacobian.Width(),
+            "The reference H(curl) curl has the wrong dimension."
+        );
+
+        physical_curl.SetSize(reference_curl.Size());
+        context.mapping_jacobian.Mult(reference_curl, physical_curl);
+        physical_curl /= context.mapping_determinant;
+    }
+
+    void MapPhysicalCurlToHCurlReference(
+        const MappingPointContext &context,
+        const mfem::Vector &physical_curl,
+        mfem::Vector &reference_curl
+    ) {
+        MFEM_VERIFY(
+            physical_curl.Size() == context.inverse_mapping_jacobian.Width(),
+            "The physical H(curl) curl has the wrong dimension."
+        );
+
+        reference_curl.SetSize(physical_curl.Size());
+        context.inverse_mapping_jacobian.Mult(physical_curl, reference_curl);
+        reference_curl *= context.mapping_determinant;
+    }
+
+    // TODO: Investigate these
+    void ComputeHCurlMassTensor(
+        const MappingPointContext &context,
+        mfem::DenseMatrix &mass_tensor
+    ) {
+        ComputeScalarDiffusionTensor(context, mass_tensor);
+    }
+
+    void ComputeHCurlCurlTensor(
+        const MappingPointContext &context,
+        mfem::DenseMatrix &curl_tensor
+    ) {
+        ComputeHDivMassTensor(context, curl_tensor);
+    }
+
+    void ComputeHDivMassTensorVariation(
+        const MappingPointContext &context,
+        const MappingPointVariation &variation,
+        mfem::DenseMatrix &mass_tensor_variation
+    ) {
+        const double determinant = context.mapping_determinant;
+        const double determinant_variation =
+            variation.mapping_determinant_variation;
+        const int dimension = context.inverse_mapping_jacobian.Width();
+
+        mass_tensor_variation.SetSize(dimension, dimension);
+
+        MFEM_VERIFY(
+            std::isfinite(determinant) && determinant > 0.0,
+            "The mapping determinant must be positive and finite."
+        );
+        MFEM_VERIFY(
+            std::isfinite(determinant_variation),
+            "The mapping determinant variation must be finite."
+        );
+
+        mfem::DenseMatrix determinant_correction(dimension, dimension);
+        ComputeHDivMassTensor(context, determinant_correction);
+        determinant_correction *= determinant_variation / determinant;
+
+        mfem::DenseMatrix right_jacobian_variation(dimension, dimension);
+        mfem::MultAtB(
+            context.mapping_jacobian, variation.mapping_jacobian_variation,
+            right_jacobian_variation
+        );
+        mfem::MultAtB(
+            variation.mapping_jacobian_variation, context.mapping_jacobian,
+            mass_tensor_variation
+        );
+
+        mass_tensor_variation += right_jacobian_variation;
+        mass_tensor_variation *= 1 / determinant;
+        mass_tensor_variation -= determinant_correction;
+    }
+} // namespace mean_field::mapping

libmeanfield/impl/operators/contexts/barotropic_closure_linearization_context.cpp

@@ -0,0 +1,135 @@
+module;
+
+#include <cstdint>
+
+#include <mfem.hpp>
+
+module mean_field;
+import :operators.context.barotropic_closure_linearization;
+
+namespace mean_field::operators::context::barotropic {
+    BarotropicClosureLinearizationContext::
+        BarotropicClosureLinearizationContext(
+            const fem::FEM &f,
+            const mapping::DomainMapperStateless &domainMapper,
+            const physics::PolytropicBarotrope &barotrope
+        )
+        : m_f(f),
+          m_operator(
+              f,
+              domainMapper,
+              barotrope
+          ) {
+        MFEM_VERIFY(
+            m_f.densityFes != nullptr,
+            "The closure linearization context requires the "
+            "density finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_f.enthalpyFes != nullptr,
+            "The closure linearization context requires the "
+            "enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_f.displacementFes != nullptr,
+            "The closure linearization context requires the "
+            "displacement finite-element space."
+        );
+    }
+
+    void BarotropicClosureLinearizationContext::Prepare(
+        const mfem::Vector &baseDensityTrue,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &displacementTrue,
+        const BarotropicClosureRevisions &revisions
+    ) {
+        MFEM_VERIFY(
+            baseDensityTrue.Size() == m_f.densityFes->GetTrueVSize(),
+            "The closure base-density vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            baseEnthalpyTrue.Size() == m_f.enthalpyFes->GetTrueVSize(),
+            "The closure base-enthalpy vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == m_f.displacementFes->GetTrueVSize(),
+            "The closure displacement vector has the wrong size."
+        );
+
+        if (m_isPrepared && revisions == m_revisions) {
+            return;
+        }
+
+        m_operator.Prepare(baseDensityTrue, baseEnthalpyTrue, displacementTrue);
+
+        m_baseDensityTrue  = baseDensityTrue;
+        m_baseEnthalpyTrue = baseEnthalpyTrue;
+        m_displacementTrue = displacementTrue;
+
+        m_revisions        = revisions;
+        m_isPrepared       = true;
+        ++m_preparationCount;
+    }
+
+    bool BarotropicClosureLinearizationContext::IsPrepared() const noexcept {
+        return m_isPrepared;
+    }
+
+    bool BarotropicClosureLinearizationContext::MatchesRevisions(
+        const BarotropicClosureRevisions &revisions
+    ) const noexcept {
+        return m_isPrepared && revisions == m_revisions;
+    }
+
+    std::uint64_t BarotropicClosureLinearizationContext::
+        GetPreparationCount() const noexcept {
+        return m_preparationCount;
+    }
+
+    const BarotropicClosureRevisions &
+    BarotropicClosureLinearizationContext::GetRevisions() const {
+        VerifyPrepared();
+        return m_revisions;
+    }
+
+    const mfem::Vector &
+    BarotropicClosureLinearizationContext::GetBaseDensityTrue() const {
+        VerifyPrepared();
+        return m_baseDensityTrue;
+    }
+
+    const mfem::Vector &
+    BarotropicClosureLinearizationContext::GetBaseEnthalpyTrue() const {
+        VerifyPrepared();
+        return m_baseEnthalpyTrue;
+    }
+
+    const mfem::Vector &
+    BarotropicClosureLinearizationContext::GetDisplacementTrue() const {
+        VerifyPrepared();
+        return m_displacementTrue;
+    }
+
+    const PreparedBarotropicClosureOperator &
+    BarotropicClosureLinearizationContext::GetOperator() const noexcept {
+        return m_operator;
+    }
+
+    void BarotropicClosureLinearizationContext::BuildResidual(
+        mfem::Vector &residual
+    ) const {
+        VerifyPrepared();
+        m_operator.BuildResidual(residual);
+    }
+
+    void BarotropicClosureLinearizationContext::VerifyPrepared() const {
+        MFEM_VERIFY(
+            m_isPrepared, "The barotropic-closure linearization context "
+                          "has not been prepared."
+        );
+    }
+} // namespace mean_field::operators::context::barotropic

libmeanfield/impl/operators/contexts/gravity_field_context.cpp

@@ -0,0 +1,442 @@
+module;
+#include <cmath>
+#include <memory>
+#include <mfem.hpp>
+
+module mean_field;
+import :operators.context.gravity_field;
+
+namespace {
+    void validate_displacement(
+        const mean_field::fem::FEM &f,
+        const mfem::Vector &displacement_true
+    ) {
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "GravityFieldGeometryContext requires the "
+            "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            displacement_true.Size() == f.displacementFes->GetTrueVSize(),
+            "GravityFieldGeometryContext received a displacement vector with "
+            "the "
+            "wrong size."
+        );
+
+        for (int i = 0; i < displacement_true.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(displacement_true(i)),
+                "GravityFieldGeometryContext received a non-finite "
+                "displacement "
+                "value."
+            );
+        }
+    }
+
+    void validate_linearization_state(
+        const mean_field::fem::FEM &f,
+        const mean_field::operators::context::gravity_field::
+            GravityFieldStateView &state
+    ) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr, "GravityFieldLinearizationContext "
+                                     "requires the density finite-element "
+                                     "space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "GravityFieldLinearizationContext requires the gravity-potential "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "GravityFieldLinearizationContext requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "GravityFieldLinearizationContext requires "
+            "the displacement finite-element space."
+        );
+
+        MFEM_VERIFY(
+            state.density.Size() == f.densityFes->GetTrueVSize(),
+            "GravityFieldLinearizationContext received a density vector with "
+            "the "
+            "wrong size."
+        );
+        MFEM_VERIFY(
+            state.displacement.Size() == f.displacementFes->GetTrueVSize(),
+            "GravityFieldLinearizationContext received a displacement vector "
+            "with "
+            "the wrong size."
+        );
+        MFEM_VERIFY(
+            state.gravity_gradient.Size() == f.gravityFluxFes->GetTrueVSize(),
+            "GravityFieldLinearizationContext received a gravity-gradient "
+            "vector "
+            "with the wrong size."
+        );
+        MFEM_VERIFY(
+            state.gravity_potential.Size() ==
+                f.gravityPotentialFes->GetTrueVSize(),
+            "GravityFieldLinearizationContext received a gravity-potential "
+            "vector "
+            "with the wrong size."
+        );
+
+        for (int i = 0; i < state.density.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(state.density(i)),
+                "GravityFieldLinearizationContext received a non-finite "
+                "density "
+                "value."
+            );
+        }
+
+        for (int i = 0; i < state.displacement.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(state.displacement(i)),
+                "GravityFieldLinearizationContext received a non-finite "
+                "displacement "
+                "value."
+            );
+        }
+
+        for (int i = 0; i < state.gravity_gradient.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(state.gravity_gradient(i)),
+                "GravityFieldLinearizationContext received a non-finite "
+                "gravity-gradient value."
+            );
+        }
+
+        for (int i = 0; i < state.gravity_potential.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(state.gravity_potential(i)),
+                "GravityFieldLinearizationContext received a non-finite "
+                "gravity-potential value."
+            );
+        }
+    }
+} // namespace
+
+namespace mean_field::operators::context::gravity_field {
+    GravityFieldGeometryContext::GravityFieldGeometryContext(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper
+    )
+        : m_fem(f),
+          m_domain_mapper(domain_mapper) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "GravityFieldGeometryContext requires a mesh."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "GravityFieldGeometryContext requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "GravityFieldGeometryContext requires the density finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "GravityFieldGeometryContext requires the gravity-potential "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "GravityFieldGeometryContext requires the "
+            "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "GravityFieldGeometryContext requires the compactification "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "GravityFieldGeometryContext requires the compactification "
+            "coordinate."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "GravityFieldGeometryContext requires the quadrature-rule factory."
+        );
+        MFEM_VERIFY(
+            domain_mapper.GetDimension() == f.mesh->Dimension(),
+            "The stateless domain-mapper dimension does not match the mesh "
+            "dimension."
+        );
+    }
+
+    GravityFieldGeometryPreparation GravityFieldGeometryContext::Prepare(
+        const mfem::Vector &displacement_true,
+        const DiscretizationRevision discretization_revision,
+        const DisplacementRevision displacement_revision
+    ) {
+        validate_displacement(m_fem, displacement_true);
+
+        if (m_is_prepared) {
+            MFEM_VERIFY(
+                discretization_revision >= m_discretization_revision,
+                "GravityFieldGeometryContext received an older discretization "
+                "revision."
+            );
+            MFEM_VERIFY(
+                displacement_revision >= m_displacement_revision,
+                "GravityFieldGeometryContext received an older displacement "
+                "revision."
+            );
+        }
+
+        const bool discretization_changed =
+            !m_is_prepared ||
+            discretization_revision != m_discretization_revision;
+        const bool displacement_changed =
+            !m_is_prepared || displacement_revision != m_displacement_revision;
+
+        GravityFieldGeometryPreparation preparation;
+
+        if (!discretization_changed && !displacement_changed) {
+            return preparation;
+        }
+
+        if (discretization_changed) {
+            auto mass_operator =
+                std::make_unique<PreparedMappedHDivMassOperator>(
+                    m_fem, m_domain_mapper
+                );
+            auto source_operator =
+                std::make_unique<PreparedMappedGravitySourceOperator>(
+                    m_fem, m_domain_mapper
+                );
+
+            mass_operator->Prepare(displacement_true);
+            source_operator->Prepare(displacement_true);
+
+            m_mass_operator                     = std::move(mass_operator);
+            m_source_operator                   = std::move(source_operator);
+
+            preparation.reconstructed_operators = true;
+            preparation.rebuilt_mass_operator   = true;
+            preparation.rebuilt_source_operator = true;
+        } else {
+            MFEM_VERIFY(
+                m_mass_operator != nullptr, "GravityFieldGeometryContext has "
+                                            "no prepared H(div) mass operator."
+            );
+            MFEM_VERIFY(
+                m_source_operator != nullptr,
+                "GravityFieldGeometryContext has no prepared gravity source "
+                "operator."
+            );
+
+            m_mass_operator->Prepare(displacement_true);
+            m_source_operator->Prepare(displacement_true);
+
+            preparation.rebuilt_mass_operator   = true;
+            preparation.rebuilt_source_operator = true;
+        }
+
+        m_displacement_true                   = displacement_true;
+        m_discretization_revision             = discretization_revision;
+        m_displacement_revision               = displacement_revision;
+        m_is_prepared                         = true;
+
+        preparation.refreshed_variation_state = true;
+
+        return preparation;
+    }
+
+    const PreparedMappedHDivMassOperator &
+    GravityFieldGeometryContext::GetMassOperator() const {
+        MFEM_VERIFY(
+            m_is_prepared,
+            "GravityFieldGeometryContext must be prepared before "
+            "accessing its mass operator."
+        );
+        MFEM_VERIFY(
+            m_mass_operator != nullptr,
+            "GravityFieldGeometryContext has no prepared H(div) mass operator."
+        );
+        return *m_mass_operator;
+    }
+
+    const PreparedMappedGravitySourceOperator &
+    GravityFieldGeometryContext::GetSourceOperator() const {
+        MFEM_VERIFY(
+            m_is_prepared,
+            "GravityFieldGeometryContext must be prepared before "
+            "accessing its source operator."
+        );
+        MFEM_VERIFY(
+            m_source_operator != nullptr, "GravityFieldGeometryContext has no "
+                                          "prepared gravity source operator."
+        );
+        return *m_source_operator;
+    }
+
+    const mfem::Vector &GravityFieldGeometryContext::GetDisplacement() const {
+        MFEM_VERIFY(
+            m_is_prepared,
+            "GravityFieldGeometryContext must be prepared before "
+            "accessing its displacement."
+        );
+        return m_displacement_true;
+    }
+
+    DiscretizationRevision
+    GravityFieldGeometryContext::GetDiscretizationRevision() const noexcept {
+        return m_discretization_revision;
+    }
+
+    DisplacementRevision
+    GravityFieldGeometryContext::GetDisplacementRevision() const noexcept {
+        return m_displacement_revision;
+    }
+
+    bool GravityFieldGeometryContext::IsPrepared() const noexcept {
+        return m_is_prepared;
+    }
+
+    GravityFieldLinearizationContext::GravityFieldLinearizationContext(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper
+    )
+        : m_fem(f),
+          m_geometry_context(
+              f,
+              domain_mapper
+          ) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr, "GravityFieldLinearizationContext "
+                                     "requires the density finite-element "
+                                     "space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "GravityFieldLinearizationContext requires the gravity-potential "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "GravityFieldLinearizationContext requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "GravityFieldLinearizationContext requires "
+            "the displacement finite-element space."
+        );
+    }
+
+    GravityFieldPreparationReport GravityFieldLinearizationContext::Prepare(
+        const GravityFieldStateView &state,
+        const GravityFieldRevisions &revisions
+    ) {
+        validate_linearization_state(m_fem, state);
+
+        if (m_is_prepared) {
+            MFEM_VERIFY(
+                revisions.discretization >= m_revisions.discretization,
+                "GravityFieldLinearizationContext received an older "
+                "discretization "
+                "revision."
+            );
+            MFEM_VERIFY(
+                revisions.displacement >= m_revisions.displacement,
+                "GravityFieldLinearizationContext received an older "
+                "displacement "
+                "revision."
+            );
+            MFEM_VERIFY(
+                revisions.density >= m_revisions.density,
+                "GravityFieldLinearizationContext received an older density "
+                "revision."
+            );
+            MFEM_VERIFY(
+                revisions.gravity_gradient >= m_revisions.gravity_gradient,
+                "GravityFieldLinearizationContext received an older "
+                "gravity-gradient "
+                "revision."
+            );
+            MFEM_VERIFY(
+                revisions.gravity_potential >= m_revisions.gravity_potential,
+                "GravityFieldLinearizationContext received an older "
+                "gravity-potential revision."
+            );
+        }
+
+        const bool discretization_changed =
+            !m_is_prepared ||
+            revisions.discretization != m_revisions.discretization;
+        const bool density_changed = !m_is_prepared || discretization_changed ||
+                                     revisions.density != m_revisions.density;
+        const bool gravity_gradient_changed =
+            !m_is_prepared || discretization_changed ||
+            revisions.gravity_gradient != m_revisions.gravity_gradient;
+
+        GravityFieldPreparationReport report;
+
+        report.geometry = m_geometry_context.Prepare(
+            state.displacement, revisions.discretization, revisions.displacement
+        );
+
+        if (density_changed) {
+            m_density_true         = state.density;
+            report.updated_density = true;
+        }
+
+        if (gravity_gradient_changed) {
+            m_gravity_gradient_true         = state.gravity_gradient;
+            report.updated_gravity_gradient = true;
+        }
+
+        m_revisions   = revisions;
+        m_is_prepared = true;
+
+        return report;
+    }
+
+    const GravityFieldGeometryContext &
+    GravityFieldLinearizationContext::GetGeometryContext() const {
+        MFEM_VERIFY(
+            m_is_prepared, "GravityFieldLinearizationContext must be prepared "
+                           "before accessing its geometry context."
+        );
+        return m_geometry_context;
+    }
+
+    const mfem::Vector &GravityFieldLinearizationContext::GetDensity() const {
+        MFEM_VERIFY(
+            m_is_prepared, "GravityFieldLinearizationContext must be prepared "
+                           "before accessing its density."
+        );
+        return m_density_true;
+    }
+
+    const mfem::Vector &
+    GravityFieldLinearizationContext::GetGravityGradient() const {
+        MFEM_VERIFY(
+            m_is_prepared, "GravityFieldLinearizationContext must be prepared "
+                           "before accessing its gravity gradient."
+        );
+        return m_gravity_gradient_true;
+    }
+
+    const GravityFieldRevisions &
+    GravityFieldLinearizationContext::GetRevisions() const {
+        MFEM_VERIFY(
+            m_is_prepared, "GravityFieldLinearizationContext must be prepared "
+                           "before accessing its revisions."
+        );
+        return m_revisions;
+    }
+
+    bool GravityFieldLinearizationContext::IsPrepared() const noexcept {
+        return m_is_prepared;
+    }
+} // namespace mean_field::operators::context::gravity_field

libmeanfield/impl/operators/contexts/hydrostatic_equilibrium_context.cpp

@@ -0,0 +1,309 @@
+module;
+
+#include <cmath>
+
+#include <mfem.hpp>
+
+module mean_field;
+
+import :operators.context.hydrostatic_equilibrium;
+
+namespace {
+    void validate_finite_vector(
+        const mfem::Vector &vector,
+        const char *message
+    ) {
+        for (int i = 0; i < vector.Size(); ++i) {
+            MFEM_VERIFY(std::isfinite(vector(i)), message);
+        }
+    }
+
+    void validate_state(
+        const mean_field::fem::FEM &f,
+        const mean_field::operators::context::hydrostatic::
+            HydrostaticEquilibriumStateView &state
+    ) {
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "gravity-potential finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "displacement finite-element space."
+        );
+
+        MFEM_VERIFY(
+            state.enthalpy.Size() == f.enthalpyFes->GetTrueVSize(),
+            "HydrostaticEquilibriumContext received an "
+            "enthalpy vector with the wrong size."
+        );
+
+        MFEM_VERIFY(
+            state.gravityPotential.Size() ==
+                f.gravityPotentialFes->GetTrueVSize(),
+            "HydrostaticEquilibriumContext received a "
+            "gravity-potential vector with the wrong size."
+        );
+
+        MFEM_VERIFY(
+            state.displacement.Size() == f.displacementFes->GetTrueVSize(),
+            "HydrostaticEquilibriumContext received a "
+            "displacement vector with the wrong size."
+        );
+
+        validate_finite_vector(
+            state.enthalpy, "HydrostaticEquilibriumContext received a "
+                            "non-finite enthalpy value."
+        );
+
+        validate_finite_vector(
+            state.gravityPotential, "HydrostaticEquilibriumContext received a "
+                                    "non-finite gravity-potential value."
+        );
+
+        validate_finite_vector(
+            state.displacement, "HydrostaticEquilibriumContext received a "
+                                "non-finite displacement value."
+        );
+
+        MFEM_VERIFY(
+            std::isfinite(state.bernoulliConstant),
+            "HydrostaticEquilibriumContext received a "
+            "non-finite Bernoulli constant."
+        );
+    }
+
+    template <typename Stamp>
+    void validate_dependency_transition(
+        const Stamp &prepared,
+        const Stamp &requested,
+        const char *message
+    ) {
+        MFEM_VERIFY(requested.CanFollow(prepared), message);
+    }
+} // namespace
+
+namespace mean_field::operators::context::hydrostatic {
+    HydrostaticEquilibriumContext::HydrostaticEquilibriumContext(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper
+    )
+        : m_f(f),
+          m_domainMapper(domainMapper) {
+        MFEM_VERIFY(
+            m_f.mesh != nullptr,
+            "HydrostaticEquilibriumContext requires a mesh."
+        );
+
+        MFEM_VERIFY(
+            m_f.enthalpyFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_f.gravityPotentialFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "gravity-potential finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_f.displacementFes != nullptr,
+            "HydrostaticEquilibriumContext requires the "
+            "displacement finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_domainMapper.GetDimension() == m_f.mesh->Dimension(),
+            "The hydrostatic context's stateless "
+            "domain-mapper dimension does not match the mesh "
+            "dimension."
+        );
+    }
+
+    HydrostaticPreparationReport HydrostaticEquilibriumContext::Prepare(
+        const HydrostaticEquilibriumStateView &state,
+        const HydrostaticEquilibriumDependencies &dependencies
+    ) {
+        validate_state(m_f, state);
+
+        if (m_isPrepared) {
+            validate_dependency_transition(
+                m_dependencies.discretization, dependencies.discretization,
+                "HydrostaticEquilibriumContext received an older "
+                "discretization revision for the same identity."
+            );
+
+            validate_dependency_transition(
+                m_dependencies.enthalpy, dependencies.enthalpy,
+                "HydrostaticEquilibriumContext received an older "
+                "enthalpy revision for the same identity."
+            );
+
+            validate_dependency_transition(
+                m_dependencies.gravityPotential, dependencies.gravityPotential,
+                "HydrostaticEquilibriumContext received an older "
+                "gravity-potential revision for the same identity."
+            );
+
+            validate_dependency_transition(
+                m_dependencies.displacement, dependencies.displacement,
+                "HydrostaticEquilibriumContext received an older "
+                "displacement revision for the same identity."
+            );
+
+            validate_dependency_transition(
+                m_dependencies.rotation, dependencies.rotation,
+                "HydrostaticEquilibriumContext received an older "
+                "rotation revision for the same identity."
+            );
+
+            validate_dependency_transition(
+                m_dependencies.bernoulliConstant,
+                dependencies.bernoulliConstant,
+                "HydrostaticEquilibriumContext received an older "
+                "Bernoulli-constant revision for the same identity."
+            );
+        }
+
+        const bool staticChanged =
+            !m_isPrepared ||
+            dependencies.discretization != m_dependencies.discretization;
+
+        const bool enthalpyChanged =
+            !m_isPrepared || dependencies.enthalpy != m_dependencies.enthalpy;
+
+        const bool gravityPotentialChanged =
+            !m_isPrepared ||
+            dependencies.gravityPotential != m_dependencies.gravityPotential;
+
+        const bool displacementChanged =
+            !m_isPrepared ||
+            dependencies.displacement != m_dependencies.displacement;
+
+        const bool rotationChanged =
+            !m_isPrepared || dependencies.rotation != m_dependencies.rotation;
+
+        const bool bernoulliConstantChanged =
+            !m_isPrepared ||
+            dependencies.bernoulliConstant != m_dependencies.bernoulliConstant;
+
+        const bool geometryPreparationRequired =
+            staticChanged || displacementChanged;
+
+        const bool rotationPreparationRequired =
+            geometryPreparationRequired || rotationChanged;
+
+        const bool baseStatePreparationRequired =
+            rotationPreparationRequired || enthalpyChanged ||
+            gravityPotentialChanged || bernoulliConstantChanged;
+
+        HydrostaticPreparationReport report;
+
+        report.preparedStaticDependencies   = staticChanged;
+        report.preparedGeometryState        = geometryPreparationRequired;
+        report.preparedRotationDependencies = rotationPreparationRequired;
+        report.preparedBaseState            = baseStatePreparationRequired;
+
+        if (staticChanged || enthalpyChanged) {
+            m_baseEnthalpyTrue     = state.enthalpy;
+            report.updatedEnthalpy = true;
+        }
+
+        if (staticChanged || gravityPotentialChanged) {
+            m_baseGravityPotentialTrue     = state.gravityPotential;
+
+            report.updatedGravityPotential = true;
+        }
+
+        if (geometryPreparationRequired) {
+            m_displacementTrue         = state.displacement;
+            report.updatedDisplacement = true;
+        }
+
+        if (staticChanged || bernoulliConstantChanged) {
+            m_bernoulliConstant             = state.bernoulliConstant;
+            report.updatedBernoulliConstant = true;
+        }
+
+        if (report.preparedStaticDependencies) {
+            ++m_statistics.staticPreparations;
+        }
+
+        if (report.preparedGeometryState) {
+            ++m_statistics.geometryPreparations;
+        }
+
+        if (report.preparedRotationDependencies) {
+            ++m_statistics.rotationPreparations;
+        }
+
+        if (report.preparedBaseState) {
+            ++m_statistics.baseStatePreparations;
+        }
+
+        m_dependencies = dependencies;
+        m_isPrepared   = true;
+
+        return report;
+    }
+
+    bool HydrostaticEquilibriumContext::IsPrepared() const noexcept {
+        return m_isPrepared;
+    }
+
+    bool HydrostaticEquilibriumContext::MatchesDependencies(
+        const HydrostaticEquilibriumDependencies &dependencies
+    ) const noexcept {
+        return m_isPrepared && dependencies == m_dependencies;
+    }
+
+    const HydrostaticEquilibriumDependencies &
+    HydrostaticEquilibriumContext::GetDependencies() const {
+        VerifyPrepared();
+        return m_dependencies;
+    }
+
+    const HydrostaticPreparationStatistics &
+    HydrostaticEquilibriumContext::GetPreparationStatistics() const noexcept {
+        return m_statistics;
+    }
+
+    const mfem::Vector &
+    HydrostaticEquilibriumContext::GetBaseEnthalpyTrue() const {
+        VerifyPrepared();
+        return m_baseEnthalpyTrue;
+    }
+
+    const mfem::Vector &
+    HydrostaticEquilibriumContext::GetBaseGravityPotentialTrue() const {
+        VerifyPrepared();
+        return m_baseGravityPotentialTrue;
+    }
+
+    const mfem::Vector &
+    HydrostaticEquilibriumContext::GetDisplacementTrue() const {
+        VerifyPrepared();
+        return m_displacementTrue;
+    }
+
+    double HydrostaticEquilibriumContext::GetBernoulliConstant() const {
+        VerifyPrepared();
+        return m_bernoulliConstant;
+    }
+
+    void HydrostaticEquilibriumContext::VerifyPrepared() const {
+        MFEM_VERIFY(
+            m_isPrepared, "HydrostaticEquilibriumContext has not been prepared."
+        );
+    }
+} // namespace mean_field::operators::context::hydrostatic

libmeanfield/impl/operators/gravity_field.cpp

@@ -0,0 +1,790 @@
+module;
+#include "profile.h"
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <mfem.hpp>
+
+module mean_field;
+import :operators.gravity_field;
+import :solver.fields;
+import :operators.kernels.gravity_field;
+
+namespace {
+    using namespace mean_field;
+    int get_state_width(const mfem::Array<int> &state_true_offsets) {
+        MFEM_VERIFY(
+            state_true_offsets.Size() >= 2,
+            "The coupled state requires at least one block."
+        );
+        MFEM_VERIFY(
+            state_true_offsets[0] == 0,
+            "The coupled state offsets must begin at zero."
+        );
+
+        for (int i = 0; i < state_true_offsets.Size() - 1; ++i) {
+            MFEM_VERIFY(
+                state_true_offsets[i + 1] >= state_true_offsets[i],
+                "The coupled state offsets must be nondecreasing."
+            );
+        }
+
+        MFEM_VERIFY(
+            state_true_offsets.Last() > 0, "The coupled state cannot be empty."
+        );
+        return state_true_offsets.Last();
+    }
+
+    int get_gravity_residual_height(const fem::FEM &f) {
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "GravityFieldOperator requires the gravity-gradient finite-element "
+            "space (RT: Raviart-Thomas)."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "GravityFieldOperator requires the gravity-potential "
+            "finite-element "
+            "space (L2: Lebesgue "
+            "space of square-integrable functions)."
+        );
+        return f.gravityFluxFes->GetTrueVSize() +
+               f.gravityPotentialFes->GetTrueVSize();
+    }
+
+    mfem::Array<int> make_gravity_residual_offsets(const fem::FEM &f) {
+        mfem::Array<int> offsets(operators::gravity_residual_block_count + 1);
+        offsets[0] = 0;
+        offsets[1] = f.gravityFluxFes->GetTrueVSize();
+        offsets[2] = offsets[1] + f.gravityPotentialFes->GetTrueVSize();
+        return offsets;
+    }
+
+    template <int index>
+    int get_state_block_size(
+        const mfem::Array<int> &state_true_offsets,
+        const utils::blocks::value_block<index>
+    ) {
+        MFEM_VERIFY(
+            index + 1 < state_true_offsets.Size(),
+            "Value block is not present in the state offsets."
+        );
+        return state_true_offsets[index + 1] - state_true_offsets[index];
+    }
+
+    void validate_state_offsets(
+        const fem::FEM &f,
+        const mfem::Array<int> &state_true_offsets
+    ) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "GravityFieldOperator requires the density finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr, "GravityFieldOperator requires the "
+                                          "displacement finite-element space."
+        );
+
+        using form                   = utils::blocks::gravity_field_form;
+
+        constexpr auto density_block = utils::blocks::get_value_block<form>(
+            utils::blocks::density_field.mass_term
+        );
+        constexpr auto displacement_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::displacement_field.geometry_term
+            );
+        constexpr auto gravity_gradient_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        MFEM_VERIFY(
+            state_true_offsets.Size() == form::value_block_count + 1,
+            "The gravity state offsets do not match gravity_field_form."
+        );
+        MFEM_VERIFY(
+            get_state_block_size(state_true_offsets, density_block) ==
+                f.densityFes->GetTrueVSize(),
+            "The density block does not match the density finite-element space."
+        );
+        MFEM_VERIFY(
+            get_state_block_size(state_true_offsets, displacement_block) ==
+                f.displacementFes->GetTrueVSize(),
+            "The displacement block does not match the displacement "
+            "finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            get_state_block_size(state_true_offsets, gravity_gradient_block) ==
+                f.gravityFluxFes->GetTrueVSize(),
+            "The gravity-gradient block does not match the RT finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            get_state_block_size(state_true_offsets, gravity_potential_block) ==
+                f.gravityPotentialFes->GetTrueVSize(),
+            "The gravity-potential block does not match the potential "
+            "finite-element space."
+        );
+    }
+
+    void validate_gravity_context(const fem::FEM &f) {
+        MFEM_VERIFY(
+            f.gravityContext.b_form != nullptr,
+            "GravityFieldOperator requires the divergence operator."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.BT != nullptr,
+            "GravityFieldOperator requires the transpose divergence operator."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "GravityFieldOperator requires the quadrature-rule factory."
+        );
+    }
+
+    template <int index>
+    mfem::Vector make_read_only_value_view(
+        const mfem::Vector &vector,
+        const mfem::Array<int> &offsets,
+        const utils::blocks::value_block<index>
+    ) {
+        MFEM_VERIFY(
+            index + 1 < offsets.Size(),
+            "Value block is not present in the supplied offset array."
+        );
+
+        const int begin = offsets[index];
+        const int size  = offsets[index + 1] - begin;
+
+        MFEM_VERIFY(
+            vector.Size() == offsets.Last(),
+            "Vector size does not match the value-block offsets."
+        );
+        return mfem::Vector(
+            const_cast<mfem::real_t *>(vector.GetData()) + begin, size
+        );
+    }
+
+    template <int index>
+    mfem::Vector make_read_only_residual_view(
+        const mfem::Vector &vector,
+        const mfem::Array<int> &offsets,
+        const utils::blocks::residual_block<index> block
+    ) {
+        const int block_id = block;
+        const int begin    = offsets[block_id];
+        const int size     = offsets[block_id + 1] - begin;
+
+        MFEM_VERIFY(
+            vector.Size() == offsets.Last(),
+            "The vector does not match the residual-block layout."
+        );
+
+        mfem::Vector view;
+        view.MakeRef(const_cast<mfem::Vector &>(vector), begin, size);
+        return view;
+    }
+
+    template <int index>
+    mfem::Vector make_residual_view(
+        mfem::Vector &vector,
+        const mfem::Array<int> &offsets,
+        const utils::blocks::residual_block<index>
+    ) {
+        MFEM_VERIFY(
+            index + 1 < offsets.Size(),
+            "Residual block is not present in the supplied offset array."
+        );
+
+        const int begin = offsets[index];
+        const int size  = offsets[index + 1] - begin;
+
+        MFEM_VERIFY(
+            vector.Size() == offsets.Last(),
+            "Vector size does not match the residual-block offsets."
+        );
+        return mfem::Vector(vector.GetData() + begin, size);
+    }
+} // namespace
+
+namespace mean_field::operators {
+    GravityFieldOperator::GravityFieldOperator(
+        fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper,
+        context::gravity_field::GravityFieldLinearizationContext
+            &linearization_context,
+        const mfem::Array<int> &state_true_offsets,
+        GravityFieldJacobianOperator &jacobian
+    )
+        : Operator(
+              get_gravity_residual_height(f),
+              get_state_width(state_true_offsets)
+          ),
+          m_fem(f),
+          m_domain_mapper(domain_mapper),
+          m_linearization_context(linearization_context),
+          m_state_true_offsets(state_true_offsets),
+          m_residual_true_offsets(make_gravity_residual_offsets(f)),
+          m_jacobian(jacobian) {
+        MFEM_VERIFY(f.mesh != nullptr, "GravityFieldOperator requires a mesh.");
+        MFEM_VERIFY(
+            f.displacementFes != nullptr, "GravityFieldOperator requires the "
+                                          "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.smesh.exterior_coordinate != nullptr,
+            "GravityFieldOperator requires the STROID exterior coordinate."
+        );
+        MFEM_VERIFY(
+            f.smesh.exterior_coordinate->space != nullptr,
+            "GravityFieldOperator requires the exterior-coordinate "
+            "finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            f.smesh.exterior_coordinate->values != nullptr,
+            "GravityFieldOperator requires the exterior-coordinate values."
+        );
+        MFEM_VERIFY(
+            domain_mapper.GetDimension() == f.mesh->Dimension(),
+            "GravityFieldOperator received a domain mapper with the wrong "
+            "dimension."
+        );
+
+        validate_state_offsets(f, m_state_true_offsets);
+        validate_gravity_context(f);
+
+        bool has_vacuum_domain = false;
+
+        for (int i = 0; i < f.mesh->attributes.Size(); ++i) {
+            if (f.mesh->attributes[i] ==
+                domain_mapper.GetVacuumElementAttribute()) {
+                has_vacuum_domain = true;
+                break;
+            }
+        }
+
+        MFEM_VERIFY(
+            has_vacuum_domain,
+            "GravityFieldOperator requires a compactified vacuum domain."
+        );
+        MFEM_VERIFY(
+            m_residual_true_offsets.Last() == Height(),
+            "The gravity residual offsets do not match the operator height."
+        );
+        MFEM_VERIFY(
+            m_state_true_offsets.Last() == Width(),
+            "The coupled state offsets do not match the operator width."
+        );
+    }
+
+    context::gravity_field::GravityFieldPreparationReport
+    GravityFieldOperator::Prepare(
+        const mfem::Vector &state,
+        const context::gravity_field::GravityFieldRevisions &revisions
+    ) {
+        using form                   = utils::blocks::gravity_field_form;
+
+        constexpr auto density_block = utils::blocks::get_value_block<form>(
+            utils::blocks::density_field.mass_term
+        );
+        constexpr auto displacement_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::displacement_field.geometry_term
+            );
+        constexpr auto gravity_gradient_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        MFEM_VERIFY(
+            state.Size() == Width(), "GravityFieldOperator received a "
+                                     "preparation state with the wrong size."
+        );
+
+        const mfem::Vector density = make_read_only_value_view(
+            state, m_state_true_offsets, density_block
+        );
+        const mfem::Vector displacement = make_read_only_value_view(
+            state, m_state_true_offsets, displacement_block
+        );
+        const mfem::Vector gravity_gradient = make_read_only_value_view(
+            state, m_state_true_offsets, gravity_gradient_block
+        );
+        const mfem::Vector gravity_potential = make_read_only_value_view(
+            state, m_state_true_offsets, gravity_potential_block
+        );
+
+        return m_linearization_context.Prepare(
+            {.density           = density,
+             .displacement      = displacement,
+             .gravity_gradient  = gravity_gradient,
+             .gravity_potential = gravity_potential},
+            revisions
+        );
+    }
+
+    const mfem::Array<int> &
+    GravityFieldOperator::GetStateTrueOffsets() const noexcept {
+        return m_state_true_offsets;
+    }
+
+    const mfem::Array<int> &
+    GravityFieldOperator::GetResidualTrueOffsets() const noexcept {
+        return m_residual_true_offsets;
+    }
+
+    void GravityFieldOperator::ApplyGravityUnknowns(
+        const mfem::Vector &gravity_gradient,
+        const mfem::Vector &gravity_potential,
+        const context::gravity_field::GravityFieldGeometryContext
+            &geometry_context,
+        mfem::Vector &action
+    ) const {
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto gravity_gradient_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        MFEM_VERIFY(
+            geometry_context.IsPrepared(),
+            "GravityFieldOperator received an unprepared geometry context."
+        );
+        MFEM_VERIFY(
+            gravity_gradient.Size() == m_fem.gravityFluxFes->GetTrueVSize(),
+            "GravityFieldOperator received a gravity-gradient vector with the "
+            "wrong size."
+        );
+        MFEM_VERIFY(
+            gravity_potential.Size() ==
+                m_fem.gravityPotentialFes->GetTrueVSize(),
+            "GravityFieldOperator received a gravity-potential vector with the "
+            "wrong size."
+        );
+
+        action.SetSize(Height());
+        action                               = 0.0;
+
+        mfem::Vector gravity_gradient_action = make_residual_view(
+            action, m_residual_true_offsets, gravity_gradient_residual_block
+        );
+        mfem::Vector gravity_poisson_action = make_residual_view(
+            action, m_residual_true_offsets, gravity_poisson_residual_block
+        );
+        mfem::Vector transpose_divergence_action(
+            gravity_gradient_action.Size()
+        );
+
+        geometry_context.GetMassOperator().Mult(
+            gravity_gradient, gravity_gradient_action
+        );
+        m_fem.gravityContext.BT->Mult(
+            gravity_potential, transpose_divergence_action
+        );
+        gravity_gradient_action += transpose_divergence_action;
+        m_fem.gravityContext.b_form->Mult(
+            gravity_gradient, gravity_poisson_action
+        );
+    }
+
+    void GravityFieldOperator::ApplyDensitySource(
+        const mfem::Vector &density,
+        const context::gravity_field::GravityFieldGeometryContext
+            &geometry_context,
+        mfem::Vector &action
+    ) const {
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        MFEM_VERIFY(
+            geometry_context.IsPrepared(),
+            "GravityFieldOperator received an unprepared geometry context."
+        );
+        MFEM_VERIFY(
+            density.Size() == m_fem.densityFes->GetTrueVSize(),
+            "GravityFieldOperator received a density vector with the wrong "
+            "size."
+        );
+
+        action.SetSize(Height());
+        action                              = 0.0;
+
+        mfem::Vector gravity_poisson_action = make_residual_view(
+            action, m_residual_true_offsets, gravity_poisson_residual_block
+        );
+        geometry_context.GetSourceOperator().Mult(
+            density, gravity_poisson_action
+        );
+    }
+
+    void GravityFieldOperator::Mult(
+        const mfem::Vector &state,
+        mfem::Vector &residual
+    ) const {
+        MEAN_FIELD_PROFILE_SCOPE("GravityFieldOperator::Mult");
+
+        using form                   = utils::blocks::gravity_field_form;
+
+        constexpr auto density_block = utils::blocks::get_value_block<form>(
+            utils::blocks::density_field.mass_term
+        );
+        constexpr auto gravity_gradient_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        MFEM_VERIFY(
+            state.Size() == Width(),
+            "GravityFieldOperator received a state with the wrong size."
+        );
+        MFEM_VERIFY(
+            m_linearization_context.IsPrepared(),
+            "GravityFieldOperator must be prepared before Mult is called."
+        );
+
+        const mfem::Vector density = make_read_only_value_view(
+            state, m_state_true_offsets, density_block
+        );
+        const mfem::Vector gravity_gradient = make_read_only_value_view(
+            state, m_state_true_offsets, gravity_gradient_block
+        );
+        const mfem::Vector gravity_potential = make_read_only_value_view(
+            state, m_state_true_offsets, gravity_potential_block
+        );
+        const context::gravity_field::GravityFieldGeometryContext
+            &geometry_context = m_linearization_context.GetGeometryContext();
+
+        mfem::Vector source;
+
+        ApplyGravityUnknowns(
+            gravity_gradient, gravity_potential, geometry_context, residual
+        );
+        ApplyDensitySource(density, geometry_context, source);
+
+        residual -= source;
+    }
+
+    context::gravity_field::GravityFieldLinearizationContext &
+    GravityFieldOperator::GetLinearizationContext() noexcept {
+        return m_linearization_context;
+    }
+
+    const context::gravity_field::GravityFieldLinearizationContext &
+    GravityFieldOperator::GetLinearizationContext() const noexcept {
+        return m_linearization_context;
+    }
+
+    mfem::Operator &
+    GravityFieldOperator::GetGradient(const mfem::Vector &state) const {
+        MFEM_VERIFY(
+            state.Size() == Width(), "GravityFieldOperator received a "
+                                     "linearization state with the wrong size."
+        );
+        MFEM_VERIFY(
+            m_linearization_context.IsPrepared(),
+            "GravityFieldOperator must be prepared before GetGradient is "
+            "called."
+        );
+
+        return m_jacobian;
+    }
+    ReducedGravityFieldOperator::ReducedGravityFieldOperator(
+        GravityFieldOperator &gravity_field_operator,
+        context::gravity_field::GravityFieldGeometryContext
+            &gravity_field_geometry_context,
+        const mfem::Vector &displacement
+    )
+        : Operator(
+              gravity_field_operator.Height(),
+              gravity_field_operator.Height()
+          ),
+          m_gravity_field_operator(gravity_field_operator),
+          m_gravity_true_offsets(
+              gravity_field_operator.GetResidualTrueOffsets()
+          ),
+          m_gravity_field_geometry_context(gravity_field_geometry_context) {
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto gravity_gradient_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+        constexpr auto gravity_gradient_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        const mfem::Array<int> &state_offsets =
+            m_gravity_field_operator.GetStateTrueOffsets();
+
+        MFEM_VERIFY(
+            state_offsets.Size() == form::value_block_count + 1,
+            "ReducedGravityFieldOperator received an invalid full-state layout."
+        );
+        MFEM_VERIFY(
+            m_gravity_true_offsets.Size() == form::residual_block_count + 1,
+            "ReducedGravityFieldOperator received an invalid gravity-residual "
+            "layout."
+        );
+        MFEM_VERIFY(
+            state_offsets[0] == 0, "The full-state offsets must begin at zero."
+        );
+        MFEM_VERIFY(
+            m_gravity_true_offsets[0] == 0,
+            "The reduced gravity offsets must begin at zero."
+        );
+        MFEM_VERIFY(
+            state_offsets.Last() == m_gravity_field_operator.Width(),
+            "The full-state offsets do not match the gravity-field operator "
+            "width."
+        );
+        MFEM_VERIFY(
+            m_gravity_true_offsets.Last() == m_gravity_field_operator.Height(),
+            "The reduced gravity offsets do not match the gravity-field "
+            "operator "
+            "height."
+        );
+        MFEM_VERIFY(
+            Width() == Height(), "ReducedGravityFieldOperator must be square."
+        );
+
+        const int full_gradient_size =
+            state_offsets[static_cast<int>(gravity_gradient_block) + 1] -
+            state_offsets[gravity_gradient_block];
+        const int full_potential_size =
+            state_offsets[static_cast<int>(gravity_potential_block) + 1] -
+            state_offsets[gravity_potential_block];
+        const int reduced_gradient_size =
+            m_gravity_true_offsets
+                [static_cast<int>(gravity_gradient_residual_block) + 1] -
+            m_gravity_true_offsets[gravity_gradient_residual_block];
+        const int reduced_potential_size =
+            m_gravity_true_offsets
+                [static_cast<int>(gravity_poisson_residual_block) + 1] -
+            m_gravity_true_offsets[gravity_poisson_residual_block];
+
+        MFEM_VERIFY(
+            full_gradient_size == reduced_gradient_size,
+            "The reduced gravity-gradient block does not match the full-state "
+            "gravity-gradient block."
+        );
+        MFEM_VERIFY(
+            full_potential_size == reduced_potential_size,
+            "The reduced gravity-potential block does not match the Poisson "
+            "residual block."
+        );
+
+        SetDisplacement(displacement);
+    }
+
+    void ReducedGravityFieldOperator::SetDisplacement(
+        const mfem::Vector &displacement
+    ) {
+        ValidateDisplacement(displacement);
+
+        context::gravity_field::DiscretizationRevision discretization_revision;
+        context::gravity_field::DisplacementRevision displacement_revision;
+
+        if (m_gravity_field_geometry_context.IsPrepared()) {
+            discretization_revision =
+                m_gravity_field_geometry_context.GetDiscretizationRevision();
+            displacement_revision =
+                m_gravity_field_geometry_context.GetDisplacementRevision();
+
+            MFEM_VERIFY(
+                displacement_revision.value <
+                    std::numeric_limits<std::uint64_t>::max(),
+                "The reduced gravity displacement revision has overflowed."
+            );
+            ++displacement_revision.value;
+        }
+
+        m_gravity_field_geometry_context.Prepare(
+            displacement, discretization_revision, displacement_revision
+        );
+    }
+
+    const mfem::Vector &ReducedGravityFieldOperator::GetDisplacement() const {
+        return m_gravity_field_geometry_context.GetDisplacement();
+    }
+
+    void ReducedGravityFieldOperator::BuildRightHandSide(
+        const mfem::Vector &density,
+        mfem::Vector &right_hand_side
+    ) const {
+        ValidateDensity(density);
+
+        m_gravity_field_operator.ApplyDensitySource(
+            density, m_gravity_field_geometry_context, right_hand_side
+        );
+
+        MFEM_VERIFY(
+            right_hand_side.Size() == Height(),
+            "ReducedGravityFieldOperator produced a right-hand side with the "
+            "wrong "
+            "size."
+        );
+    }
+
+    void ReducedGravityFieldOperator::Mult(
+        const mfem::Vector &gravity_state,
+        mfem::Vector &action
+    ) const {
+        MEAN_FIELD_PROFILE_SCOPE("ReducedGravityFieldOperator::Mult");
+
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto gravity_gradient_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        ValidateGravityState(gravity_state);
+
+        const mfem::Vector gravity_gradient_true = make_read_only_residual_view(
+            gravity_state, m_gravity_true_offsets,
+            gravity_gradient_residual_block
+        );
+        const mfem::Vector gravity_potential_true =
+            make_read_only_residual_view(
+                gravity_state, m_gravity_true_offsets,
+                gravity_poisson_residual_block
+            );
+
+        m_gravity_field_operator.ApplyGravityUnknowns(
+            gravity_gradient_true, gravity_potential_true,
+            m_gravity_field_geometry_context, action
+        );
+
+        MFEM_VERIFY(
+            action.Size() == Height(), "ReducedGravityFieldOperator produced "
+                                       "an action with the wrong size."
+        );
+    }
+
+    GravityFieldOperator &
+    ReducedGravityFieldOperator::GetGravityFieldOperator() noexcept {
+        return m_gravity_field_operator;
+    }
+
+    const GravityFieldOperator &
+    ReducedGravityFieldOperator::GetGravityFieldOperator() const noexcept {
+        return m_gravity_field_operator;
+    }
+
+    context::gravity_field::GravityFieldGeometryContext &
+    ReducedGravityFieldOperator::GetGeometryContext() noexcept {
+        return m_gravity_field_geometry_context;
+    }
+
+    const context::gravity_field::GravityFieldGeometryContext &
+    ReducedGravityFieldOperator::GetGeometryContext() const noexcept {
+        return m_gravity_field_geometry_context;
+    }
+
+    const mfem::Array<int> &
+    ReducedGravityFieldOperator::GetGravityTrueOffsets() const noexcept {
+        return m_gravity_true_offsets;
+    }
+
+    void ReducedGravityFieldOperator::ValidateDisplacement(
+        const mfem::Vector &displacement
+    ) const {
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto displacement_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::displacement_field.geometry_term
+            );
+
+        const mfem::Array<int> &state_offsets =
+            m_gravity_field_operator.GetStateTrueOffsets();
+        const int expected_size =
+            state_offsets[static_cast<int>(displacement_block) + 1] -
+            state_offsets[displacement_block];
+
+        MFEM_VERIFY(
+            displacement.Size() == expected_size,
+            "ReducedGravityFieldOperator received a displacement with the "
+            "wrong "
+            "size."
+        );
+
+        for (int i = 0; i < displacement.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(displacement(i)),
+                "ReducedGravityFieldOperator received a non-finite "
+                "displacement "
+                "value."
+            );
+        }
+    }
+
+    void ReducedGravityFieldOperator::ValidateDensity(
+        const mfem::Vector &density
+    ) const {
+        using form                   = utils::blocks::gravity_field_form;
+
+        constexpr auto density_block = utils::blocks::get_value_block<form>(
+            utils::blocks::density_field.mass_term
+        );
+
+        const mfem::Array<int> &state_offsets =
+            m_gravity_field_operator.GetStateTrueOffsets();
+        const int expected_size =
+            state_offsets[static_cast<int>(density_block) + 1] -
+            state_offsets[density_block];
+
+        MFEM_VERIFY(
+            density.Size() == expected_size,
+            "ReducedGravityFieldOperator received a density with the wrong "
+            "size."
+        );
+    }
+
+    void ReducedGravityFieldOperator::ValidateGravityState(
+        const mfem::Vector &gravity_state
+    ) const {
+        MFEM_VERIFY(
+            gravity_state.Size() == Width(),
+            "ReducedGravityFieldOperator received "
+            "a gravity state with the wrong size."
+        );
+    }
+} // namespace mean_field::operators

libmeanfield/impl/operators/gravity_field_jacobian.cpp

@@ -0,0 +1,317 @@
+module;
+#include <mfem.hpp>
+
+module mean_field;
+import :operators.gravity_field_jacobian;
+import :operators.kernels.gravity_field;
+import :utils.blocks;
+
+namespace {
+    template <int index>
+    mfem::Vector make_read_only_value_view(
+        const mfem::Vector &vector,
+        const mfem::Array<int> &offsets,
+        const mean_field::utils::blocks::value_block<index>
+    ) {
+        const int offset = offsets[index];
+        const int size   = offsets[index + 1] - offset;
+        return mfem::Vector(
+            const_cast<mfem::real_t *>(vector.GetData()) + offset, size
+        );
+    }
+
+    template <int index>
+    mfem::Vector make_residual_view(
+        mfem::Vector &vector,
+        const mfem::Array<int> &offsets,
+        const mean_field::utils::blocks::residual_block<index>
+    ) {
+        const int offset = offsets[index];
+        const int size   = offsets[index + 1] - offset;
+        return mfem::Vector(vector.GetData() + offset, size);
+    }
+
+    template <int index>
+    int get_block_size(
+        const mfem::Array<int> &offsets,
+        const mean_field::utils::blocks::value_block<index>
+    ) {
+        return offsets[index + 1] - offsets[index];
+    }
+
+    template <int index>
+    int get_block_size(
+        const mfem::Array<int> &offsets,
+        const mean_field::utils::blocks::residual_block<index>
+    ) {
+        return offsets[index + 1] - offsets[index];
+    }
+
+    void validate_offsets(
+        const mfem::Array<int> &offsets,
+        const int block_count,
+        const char *message
+    ) {
+        MFEM_VERIFY(offsets.Size() == block_count + 1, message);
+        MFEM_VERIFY(offsets[0] == 0, "Block offsets must begin at zero.");
+
+        for (int i = 0; i < block_count; ++i)
+            MFEM_VERIFY(
+                offsets[i + 1] >= offsets[i],
+                "Block offsets must be nondecreasing."
+            );
+    }
+
+    void validate_layout(
+        const mean_field::fem::FEM &f,
+        const mfem::Array<int> &state_offsets,
+        const mfem::Array<int> &residual_offsets
+    ) {
+        using form = mean_field::utils::blocks::gravity_field_form;
+
+        constexpr auto density_block =
+            mean_field::utils::blocks::get_value_block<form>(
+                mean_field::utils::blocks::density_field.mass_term
+            );
+        constexpr auto displacement_block =
+            mean_field::utils::blocks::get_value_block<form>(
+                mean_field::utils::blocks::displacement_field.geometry_term
+            );
+        constexpr auto gravity_gradient_block =
+            mean_field::utils::blocks::get_value_block<form>(
+                mean_field::utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            mean_field::utils::blocks::get_value_block<form>(
+                mean_field::utils::blocks::gravity_field.poisson_term
+            );
+        constexpr auto gravity_gradient_residual_block =
+            mean_field::utils::blocks::get_residual_block<form>(
+                mean_field::utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_poisson_residual_block =
+            mean_field::utils::blocks::get_residual_block<form>(
+                mean_field::utils::blocks::gravity_field.poisson_term
+            );
+
+        validate_offsets(
+            state_offsets, form::value_block_count,
+            "Gravity Jacobian state offsets do not match the gravity field "
+            "form."
+        );
+        validate_offsets(
+            residual_offsets, form::residual_block_count,
+            "Gravity Jacobian residual offsets do not match the gravity field "
+            "form."
+        );
+
+        MFEM_VERIFY(
+            get_block_size(state_offsets, density_block) ==
+                f.densityFes->GetTrueVSize(),
+            "The Jacobian density block has the wrong size."
+        );
+        MFEM_VERIFY(
+            get_block_size(state_offsets, displacement_block) ==
+                f.displacementFes->GetTrueVSize(),
+            "The Jacobian displacement block has the wrong size."
+        );
+        MFEM_VERIFY(
+            get_block_size(state_offsets, gravity_gradient_block) ==
+                f.gravityFluxFes->GetTrueVSize(),
+            "The Jacobian gravity-gradient block has the wrong size."
+        );
+        MFEM_VERIFY(
+            get_block_size(state_offsets, gravity_potential_block) ==
+                f.gravityPotentialFes->GetTrueVSize(),
+            "The Jacobian gravity-potential block has the wrong size."
+        );
+        MFEM_VERIFY(
+            get_block_size(residual_offsets, gravity_gradient_residual_block) ==
+                f.gravityFluxFes->GetTrueVSize(),
+            "The Jacobian gradient-residual block has the wrong size."
+        );
+        MFEM_VERIFY(
+            get_block_size(residual_offsets, gravity_poisson_residual_block) ==
+                f.gravityPotentialFes->GetTrueVSize(),
+            "The Jacobian Poisson-residual block has the wrong size."
+        );
+    }
+} // namespace
+
+namespace mean_field::operators {
+    GravityFieldJacobianOperator::GravityFieldJacobianOperator(
+        fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper,
+        const context::gravity_field::GravityFieldLinearizationContext
+            &linearization_context,
+        const mfem::Array<int> &state_true_offsets,
+        const mfem::Array<int> &residual_true_offsets
+    )
+        : Operator(
+              residual_true_offsets.Last(),
+              state_true_offsets.Last()
+          ),
+          m_fem(f),
+          m_domain_mapper(domain_mapper),
+          m_linearization_context(linearization_context),
+          m_state_true_offsets(state_true_offsets),
+          m_residual_true_offsets(residual_true_offsets) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "GravityFieldJacobianOperator requires the density finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "GravityFieldJacobianOperator requires the gravity-potential "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "GravityFieldJacobianOperator requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "GravityFieldJacobianOperator requires the "
+            "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.b_form != nullptr,
+            "GravityFieldJacobianOperator requires the divergence operator."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.BT != nullptr,
+            "GravityFieldJacobianOperator requires the transpose divergence "
+            "operator."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "GravityFieldJacobianOperator requires the quadrature-rule factory."
+        );
+        MFEM_VERIFY(
+            domain_mapper.GetDimension() == f.mesh->Dimension(),
+            "GravityFieldJacobianOperator received a domain mapper with the "
+            "wrong "
+            "dimension."
+        );
+
+        validate_layout(f, m_state_true_offsets, m_residual_true_offsets);
+    }
+
+    void GravityFieldJacobianOperator::Mult(
+        const mfem::Vector &direction,
+        mfem::Vector &action
+    ) const {
+        MFEM_VERIFY(
+            m_linearization_context.IsPrepared(),
+            "GravityFieldJacobianOperator requires a prepared linearization "
+            "context."
+        );
+        MFEM_VERIFY(
+            direction.Size() == Width(),
+            "GravityFieldJacobianOperator received a direction with the wrong "
+            "size."
+        );
+
+        using form                   = utils::blocks::gravity_field_form;
+
+        constexpr auto density_block = utils::blocks::get_value_block<form>(
+            utils::blocks::density_field.mass_term
+        );
+        constexpr auto displacement_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::displacement_field.geometry_term
+            );
+        constexpr auto gravity_gradient_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_potential_block =
+            utils::blocks::get_value_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+        constexpr auto gravity_gradient_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        const context::gravity_field::GravityFieldGeometryContext
+            &geometry_context = m_linearization_context.GetGeometryContext();
+        const mfem::Vector &density      = m_linearization_context.GetDensity();
+        const mfem::Vector &displacement = geometry_context.GetDisplacement();
+        const mfem::Vector &gravity_gradient =
+            m_linearization_context.GetGravityGradient();
+
+        const mfem::Vector density_direction = make_read_only_value_view(
+            direction, m_state_true_offsets, density_block
+        );
+        const mfem::Vector displacement_direction = make_read_only_value_view(
+            direction, m_state_true_offsets, displacement_block
+        );
+        const mfem::Vector gravity_gradient_direction =
+            make_read_only_value_view(
+                direction, m_state_true_offsets, gravity_gradient_block
+            );
+        const mfem::Vector gravity_potential_direction =
+            make_read_only_value_view(
+                direction, m_state_true_offsets, gravity_potential_block
+            );
+
+        action.SetSize(Height());
+        action                               = 0.0;
+
+        mfem::Vector gravity_gradient_action = make_residual_view(
+            action, m_residual_true_offsets, gravity_gradient_residual_block
+        );
+        mfem::Vector gravity_poisson_action = make_residual_view(
+            action, m_residual_true_offsets, gravity_poisson_residual_block
+        );
+
+        mfem::Vector transpose_divergence_action;
+        mfem::Vector source_action;
+        mfem::Vector mass_variation_action;
+        mfem::Vector source_variation_action;
+
+        geometry_context.GetMassOperator().Mult(
+            gravity_gradient_direction, gravity_gradient_action
+        );
+        geometry_context.GetSourceOperator().Mult(
+            density_direction, source_action
+        );
+
+        kernels::apply_mapped_hdiv_mass_variation(
+            m_fem, m_domain_mapper, gravity_gradient, displacement,
+            displacement_direction, mass_variation_action
+        );
+
+        kernels::apply_mapped_source_variation(
+            m_fem, m_domain_mapper, density, displacement,
+            displacement_direction, source_variation_action
+        );
+
+        transpose_divergence_action.SetSize(gravity_gradient_action.Size());
+        m_fem.gravityContext.BT->Mult(
+            gravity_potential_direction, transpose_divergence_action
+        );
+
+        gravity_gradient_action += transpose_divergence_action;
+        gravity_gradient_action += mass_variation_action;
+
+        m_fem.gravityContext.b_form->Mult(
+            gravity_gradient_direction, gravity_poisson_action
+        );
+
+        gravity_poisson_action -= source_action;
+        gravity_poisson_action -= source_variation_action;
+    }
+
+    const context::gravity_field::GravityFieldLinearizationContext &
+    GravityFieldJacobianOperator::GetLinearizationContext() const noexcept {
+        return m_linearization_context;
+    }
+} // namespace mean_field::operators

libmeanfield/impl/operators/kernels/barotropic_closure_kernels.cpp

@@ -0,0 +1,811 @@
+module;
+
+#include <array>
+#include <cmath>
+#include <limits>
+#include <mfem.hpp>
+
+module mean_field;
+
+import :operators.kernels.barotropic_closure;
+
+namespace {
+    enum class ClosureAction { residual, density, enthalpy };
+
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &trueVector,
+        mfem::Vector &localVector
+    ) {
+        MFEM_VERIFY(
+            trueVector.Size() == finiteElementSpace.GetTrueVSize(),
+            "True vector has the wrong size."
+        );
+
+        localVector.SetSize(finiteElementSpace.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(trueVector, localVector);
+        } else {
+            localVector = trueVector;
+        }
+    }
+
+    void local_to_true(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &localVector,
+        mfem::Vector &trueVector
+    ) {
+        MFEM_VERIFY(
+            localVector.Size() == finiteElementSpace.GetVSize(),
+            "Local vector has the wrong size."
+        );
+
+        trueVector.SetSize(finiteElementSpace.GetTrueVSize());
+        trueVector = 0.0;
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->MultTranspose(localVector, trueVector);
+        } else {
+            trueVector = localVector;
+        }
+    }
+
+    int get_eos_extra_order(
+        const mean_field::physics::PolytropicBarotrope &barotrope
+    ) {
+        const double extraOrder =
+            (barotrope.polytropic_index() - 1.0) *
+            static_cast<double>(
+                mean_field::field::Enthalpy::Scalar::familyOrder
+            );
+
+        MFEM_VERIFY(
+            std::isfinite(extraOrder) && extraOrder >= 0.0 &&
+                extraOrder <=
+                    static_cast<double>(std::numeric_limits<int>::max()),
+            "The EOS effective polynomial order is invalid."
+        );
+
+        return static_cast<int>(std::ceil(extraOrder));
+    }
+
+    const mfem::IntegrationRule &get_eos_rule(
+        const mean_field::fem::FEM &f,
+        const mean_field::physics::PolytropicBarotrope &barotrope,
+        const mfem::FiniteElement &densityElement,
+        const mfem::FiniteElement &enthalpyElement,
+        const mfem::ElementTransformation &transformation
+    ) {
+        using EnthalpyField =
+            mean_field::field::Field<mean_field::field::Enthalpy>;
+
+        MFEM_VERIFY(
+            densityElement.GetOrder() ==
+                mean_field::field::Density::Scalar::familyOrder,
+            "The EOS test element does not match the "
+            "registered density field."
+        );
+
+        MFEM_VERIFY(
+            enthalpyElement.GetOrder() ==
+                mean_field::field::Enthalpy::Scalar::familyOrder,
+            "The EOS trial element does not match the "
+            "registered enthalpy field."
+        );
+
+        const mean_field::quadrature::Query query = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EosClosureSource>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(),
+            std::array<int, 1>{get_eos_extra_order(barotrope)},
+            mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const auto resolution =
+            f.quadratureFactory->get(query, transformation.GetGeometryType());
+
+        MFEM_VERIFY(
+            resolution.integration_rule != nullptr,
+            "The quadrature policy did not return an "
+            "EOS-closure integration rule."
+        );
+
+        return *resolution.integration_rule;
+    }
+
+    void validate_common_inputs(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper,
+        const mfem::Vector &displacementTrue
+    ) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "The EOS closure kernel requires a mesh."
+        );
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "The EOS closure kernel requires the density "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr,
+            "The EOS closure kernel requires the enthalpy "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "The EOS closure kernel requires the displacement "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "The EOS closure kernel requires the "
+            "compactification finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "The EOS closure kernel requires the "
+            "compactification coordinate."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "The EOS closure kernel requires the quadrature "
+            "rule factory."
+        );
+        MFEM_VERIFY(
+            displacementTrue.Size() == f.displacementFes->GetTrueVSize(),
+            "The displacement vector has the wrong size."
+        );
+        MFEM_VERIFY(
+            domainMapper.GetDimension() == f.mesh->Dimension(),
+            "The domain-mapper dimension does not match "
+            "the mesh dimension."
+        );
+    }
+
+    void apply_closure_action(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper,
+        const mean_field::physics::PolytropicBarotrope &barotrope,
+        const ClosureAction closureAction,
+        const mfem::Vector *densityInputTrue,
+        const mfem::Vector *baseEnthalpyTrue,
+        const mfem::Vector *enthalpyVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        validate_common_inputs(f, domainMapper, displacementTrue);
+
+        if (closureAction == ClosureAction::residual ||
+            closureAction == ClosureAction::density) {
+            MFEM_VERIFY(
+                densityInputTrue != nullptr &&
+                    densityInputTrue->Size() == f.densityFes->GetTrueVSize(),
+                "The density input has the wrong size."
+            );
+        }
+
+        if (closureAction == ClosureAction::residual ||
+            closureAction == ClosureAction::enthalpy) {
+            MFEM_VERIFY(
+                baseEnthalpyTrue != nullptr &&
+                    baseEnthalpyTrue->Size() == f.enthalpyFes->GetTrueVSize(),
+                "The base enthalpy has the wrong size."
+            );
+        }
+
+        if (closureAction == ClosureAction::enthalpy) {
+            MFEM_VERIFY(
+                enthalpyVariationTrue != nullptr &&
+                    enthalpyVariationTrue->Size() ==
+                        f.enthalpyFes->GetTrueVSize(),
+                "The enthalpy variation has the wrong size."
+            );
+        }
+
+        mfem::Vector densityInputLocal;
+        mfem::Vector baseEnthalpyLocal;
+        mfem::Vector enthalpyVariationLocal;
+        mfem::Vector displacementLocal;
+
+        if (densityInputTrue != nullptr) {
+            true_to_local(*f.densityFes, *densityInputTrue, densityInputLocal);
+        }
+
+        if (baseEnthalpyTrue != nullptr) {
+            true_to_local(*f.enthalpyFes, *baseEnthalpyTrue, baseEnthalpyLocal);
+        }
+
+        if (enthalpyVariationTrue != nullptr) {
+            true_to_local(
+                *f.enthalpyFes, *enthalpyVariationTrue, enthalpyVariationLocal
+            );
+        }
+
+        true_to_local(*f.displacementFes, displacementTrue, displacementLocal);
+
+        mfem::Vector localAction(f.densityFes->GetVSize());
+        localAction = 0.0;
+
+        mean_field::mapping::DomainMapperStateless::Workspace workspace(
+            f.mesh->Dimension()
+        );
+
+        mfem::Array<int> densityDofs;
+        mfem::Array<int> enthalpyDofs;
+        mfem::Array<int> displacementDofs;
+        mfem::Array<int> compactificationDofs;
+
+        mfem::Vector elementDensityInput;
+        mfem::Vector elementBaseEnthalpy;
+        mfem::Vector elementEnthalpyVariation;
+        mfem::Vector elementDisplacement;
+        mfem::Vector elementCompactification;
+        mfem::Vector elementAction;
+
+        mfem::Vector densityShape;
+        mfem::Vector enthalpyShape;
+
+        const int vacuumAttribute = domainMapper.GetVacuumElementAttribute();
+
+        for (int elementId = 0; elementId < f.mesh->GetNE(); ++elementId) {
+            mfem::ElementTransformation *transformation =
+                f.mesh->GetElementTransformation(elementId);
+
+            MFEM_VERIFY(
+                transformation != nullptr,
+                "The EOS closure kernel received a null "
+                "element transformation."
+            );
+
+            if (transformation->Attribute == vacuumAttribute) {
+                continue;
+            }
+
+            const mfem::FiniteElement &densityElement =
+                *f.densityFes->GetFE(elementId);
+            const mfem::FiniteElement &enthalpyElement =
+                *f.enthalpyFes->GetFE(elementId);
+            const mfem::FiniteElement &displacementElement =
+                *f.displacementFes->GetFE(elementId);
+            const mfem::FiniteElement &compactificationElement =
+                *f.compactificationFes->GetFE(elementId);
+
+            mfem::DofTransformation *densityDofTransformation =
+                f.densityFes->GetElementDofs(elementId, densityDofs);
+
+            mfem::DofTransformation *enthalpyDofTransformation =
+                f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
+
+            mfem::DofTransformation *displacementDofTransformation =
+                f.displacementFes->GetElementVDofs(elementId, displacementDofs);
+
+            mfem::DofTransformation *compactificationDofTransformation =
+                f.compactificationFes->GetElementDofs(
+                    elementId, compactificationDofs
+                );
+
+            if (densityInputTrue != nullptr) {
+                densityInputLocal.GetSubVector(
+                    densityDofs, elementDensityInput
+                );
+
+                if (densityDofTransformation != nullptr) {
+                    densityDofTransformation->InvTransformPrimal(
+                        elementDensityInput
+                    );
+                }
+            }
+
+            if (baseEnthalpyTrue != nullptr) {
+                baseEnthalpyLocal.GetSubVector(
+                    enthalpyDofs, elementBaseEnthalpy
+                );
+
+                if (enthalpyDofTransformation != nullptr) {
+                    enthalpyDofTransformation->InvTransformPrimal(
+                        elementBaseEnthalpy
+                    );
+                }
+            }
+
+            if (enthalpyVariationTrue != nullptr) {
+                enthalpyVariationLocal.GetSubVector(
+                    enthalpyDofs, elementEnthalpyVariation
+                );
+
+                if (enthalpyDofTransformation != nullptr) {
+                    enthalpyDofTransformation->InvTransformPrimal(
+                        elementEnthalpyVariation
+                    );
+                }
+            }
+
+            displacementLocal.GetSubVector(
+                displacementDofs, elementDisplacement
+            );
+
+            f.compactificationCoordinate->GetSubVector(
+                compactificationDofs, elementCompactification
+            );
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacement
+                );
+            }
+
+            if (compactificationDofTransformation != nullptr) {
+                compactificationDofTransformation->InvTransformPrimal(
+                    elementCompactification
+                );
+            }
+
+            const mean_field::mapping::ElementDisplacementData
+                displacementData = mean_field::mapping::
+                    ElementDisplacementDataFromElementVDofs(
+                        displacementElement, elementDisplacement
+                    );
+
+            const mean_field::mapping::ElementCompactificationData
+                compactificationData(
+                    compactificationElement, elementCompactification
+                );
+
+            const mean_field::mapping::ElementMappingData mappingData{
+                .displacement     = displacementData,
+                .compactification = compactificationData
+            };
+
+            densityShape.SetSize(densityElement.GetDof());
+            enthalpyShape.SetSize(enthalpyElement.GetDof());
+            elementAction.SetSize(densityElement.GetDof());
+            elementAction                                = 0.0;
+
+            const mfem::IntegrationRule &integrationRule = get_eos_rule(
+                f, barotrope, densityElement, enthalpyElement, *transformation
+            );
+
+            for (int quadratureIndex = 0;
+                 quadratureIndex < integrationRule.GetNPoints();
+                 ++quadratureIndex) {
+                const mfem::IntegrationPoint &integrationPoint =
+                    integrationRule.IntPoint(quadratureIndex);
+
+                transformation->SetIntPoint(&integrationPoint);
+
+                mean_field::mapping::VolumeMappingContext mappingContext;
+
+                const mean_field::mapping::MappingStatus mappingStatus =
+                    domainMapper.EvaluateVolume(
+                        mappingData, *transformation, integrationPoint,
+                        workspace, mappingContext
+                    );
+
+                MFEM_VERIFY(
+                    mappingStatus == mean_field::mapping::MappingStatus::valid,
+                    "Stateless mapping failed in the EOS "
+                    "closure kernel. Element: "
+                        << elementId
+                        << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadratureIndex
+                        << ", status: " << static_cast<int>(mappingStatus)
+                );
+
+                densityElement.CalcShape(integrationPoint, densityShape);
+
+                double integrand = 0.0;
+
+                if (closureAction == ClosureAction::density) {
+                    integrand = elementDensityInput * densityShape;
+                } else {
+                    enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
+
+                    const double baseEnthalpy =
+                        elementBaseEnthalpy * enthalpyShape;
+
+                    if (closureAction == ClosureAction::residual) {
+                        const double density =
+                            elementDensityInput * densityShape;
+
+                        integrand =
+                            density -
+                            barotrope.density_from_enthalpy(baseEnthalpy);
+                    } else {
+                        const double enthalpyVariation =
+                            elementEnthalpyVariation * enthalpyShape;
+
+                        integrand = -barotrope.density_derivative_from_enthalpy(
+                                        baseEnthalpy
+                                    ) *
+                                    enthalpyVariation;
+                    }
+                }
+
+                const double weightedIntegrand =
+                    mappingContext.quadrature.weight * integrand;
+
+                for (int densityDof = 0; densityDof < densityElement.GetDof();
+                     ++densityDof) {
+                    elementAction(densityDof) +=
+                        weightedIntegrand * densityShape(densityDof);
+                }
+            }
+
+            if (densityDofTransformation != nullptr) {
+                densityDofTransformation->TransformDual(elementAction);
+            }
+
+            localAction.AddElementVector(densityDofs, elementAction);
+        }
+
+        local_to_true(*f.densityFes, localAction, action);
+    }
+} // namespace
+
+namespace mean_field::operators::kernels {
+    void apply_barotropic_closure(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope,
+        const mfem::Vector &densityTrue,
+        const mfem::Vector &enthalpyTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &residual
+    ) {
+        apply_closure_action(
+            f, domainMapper, barotrope, ClosureAction::residual, &densityTrue,
+            &enthalpyTrue, nullptr, displacementTrue, residual
+        );
+    }
+
+    void apply_barotropic_closure_density_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope,
+        const mfem::Vector &densityVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        apply_closure_action(
+            f, domainMapper, barotrope, ClosureAction::density,
+            &densityVariationTrue, nullptr, nullptr, displacementTrue, action
+        );
+    }
+
+    void apply_barotropic_closure_enthalpy_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &enthalpyVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        apply_closure_action(
+            f, domainMapper, barotrope, ClosureAction::enthalpy, nullptr,
+            &baseEnthalpyTrue, &enthalpyVariationTrue, displacementTrue, action
+        );
+    }
+
+    void apply_barotropic_closure_displacement_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope,
+        const mfem::Vector &baseDensityTrue,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &displacementTrue,
+        const mfem::Vector &displacementVariationTrue,
+        mfem::Vector &action
+    ) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "The barotropic-closure displacement action "
+                               "requires a mesh."
+        );
+
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the density finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the displacement finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the compactification finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the compactification coordinate."
+        );
+
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "The barotropic-closure displacement action "
+            "requires the quadrature-rule factory."
+        );
+
+        MFEM_VERIFY(
+            baseDensityTrue.Size() == f.densityFes->GetTrueVSize(),
+            "The base-density vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            baseEnthalpyTrue.Size() == f.enthalpyFes->GetTrueVSize(),
+            "The base-enthalpy vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == f.displacementFes->GetTrueVSize(),
+            "The displacement vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementVariationTrue.Size() ==
+                f.displacementFes->GetTrueVSize(),
+            "The displacement-variation vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            domainMapper.GetDimension() == f.mesh->Dimension(),
+            "The domain-mapper dimension does not match the "
+            "mesh dimension."
+        );
+
+        mfem::Vector baseDensityLocal;
+        mfem::Vector baseEnthalpyLocal;
+        mfem::Vector displacementLocal;
+        mfem::Vector displacementVariationLocal;
+
+        true_to_local(*f.densityFes, baseDensityTrue, baseDensityLocal);
+
+        true_to_local(*f.enthalpyFes, baseEnthalpyTrue, baseEnthalpyLocal);
+
+        true_to_local(*f.displacementFes, displacementTrue, displacementLocal);
+
+        true_to_local(
+            *f.displacementFes, displacementVariationTrue,
+            displacementVariationLocal
+        );
+
+        mfem::Vector localAction(f.densityFes->GetVSize());
+        localAction = 0.0;
+
+        mapping::DomainMapperStateless::Workspace workspace(
+            f.mesh->Dimension()
+        );
+
+        mfem::Array<int> densityDofs;
+        mfem::Array<int> enthalpyDofs;
+        mfem::Array<int> displacementDofs;
+        mfem::Array<int> compactificationDofs;
+
+        mfem::Vector elementBaseDensity;
+        mfem::Vector elementBaseEnthalpy;
+        mfem::Vector elementDisplacement;
+        mfem::Vector elementDisplacementVariation;
+        mfem::Vector elementCompactification;
+
+        mfem::Vector densityShape;
+        mfem::Vector enthalpyShape;
+        mfem::Vector elementAction;
+
+        mapping::VolumeMappingContext mappingContext;
+        mapping::VolumeMappingVariation mappingVariation;
+
+        const int vacuumAttribute = domainMapper.GetVacuumElementAttribute();
+
+        for (int elementId = 0; elementId < f.mesh->GetNE(); ++elementId) {
+            mfem::ElementTransformation *transformation =
+                f.mesh->GetElementTransformation(elementId);
+
+            MFEM_VERIFY(
+                transformation != nullptr,
+                "The barotropic-closure displacement action "
+                "received a null element transformation."
+            );
+
+            if (transformation->Attribute == vacuumAttribute) {
+                continue;
+            }
+
+            const mfem::FiniteElement &densityElement =
+                *f.densityFes->GetFE(elementId);
+
+            const mfem::FiniteElement &enthalpyElement =
+                *f.enthalpyFes->GetFE(elementId);
+
+            const mfem::FiniteElement &displacementElement =
+                *f.displacementFes->GetFE(elementId);
+
+            const mfem::FiniteElement &compactificationElement =
+                *f.compactificationFes->GetFE(elementId);
+
+            mfem::DofTransformation *densityDofTransformation =
+                f.densityFes->GetElementDofs(elementId, densityDofs);
+
+            mfem::DofTransformation *enthalpyDofTransformation =
+                f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
+
+            mfem::DofTransformation *displacementDofTransformation =
+                f.displacementFes->GetElementVDofs(elementId, displacementDofs);
+
+            mfem::DofTransformation *compactificationDofTransformation =
+                f.compactificationFes->GetElementDofs(
+                    elementId, compactificationDofs
+                );
+
+            baseDensityLocal.GetSubVector(densityDofs, elementBaseDensity);
+
+            baseEnthalpyLocal.GetSubVector(enthalpyDofs, elementBaseEnthalpy);
+
+            displacementLocal.GetSubVector(
+                displacementDofs, elementDisplacement
+            );
+
+            displacementVariationLocal.GetSubVector(
+                displacementDofs, elementDisplacementVariation
+            );
+
+            f.compactificationCoordinate->GetSubVector(
+                compactificationDofs, elementCompactification
+            );
+
+            if (densityDofTransformation != nullptr) {
+                densityDofTransformation->InvTransformPrimal(
+                    elementBaseDensity
+                );
+            }
+
+            if (enthalpyDofTransformation != nullptr) {
+                enthalpyDofTransformation->InvTransformPrimal(
+                    elementBaseEnthalpy
+                );
+            }
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacement
+                );
+
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacementVariation
+                );
+            }
+
+            if (compactificationDofTransformation != nullptr) {
+                compactificationDofTransformation->InvTransformPrimal(
+                    elementCompactification
+                );
+            }
+
+            const mapping::ElementDisplacementData displacementData =
+                mapping::ElementDisplacementDataFromElementVDofs(
+                    displacementElement, elementDisplacement
+                );
+
+            const mapping::ElementDisplacementData displacementVariationData =
+                mapping::ElementDisplacementDataFromElementVDofs(
+                    displacementElement, elementDisplacementVariation
+                );
+
+            const mapping::ElementCompactificationData compactificationData(
+                compactificationElement, elementCompactification
+            );
+
+            const mapping::ElementMappingData mappingData{
+                .displacement     = displacementData,
+                .compactification = compactificationData
+            };
+
+            densityShape.SetSize(densityElement.GetDof());
+
+            enthalpyShape.SetSize(enthalpyElement.GetDof());
+
+            elementAction.SetSize(densityElement.GetDof());
+            elementAction                                = 0.0;
+
+            const mfem::IntegrationRule &integrationRule = get_eos_rule(
+                f, barotrope, densityElement, enthalpyElement, *transformation
+            );
+
+            for (int quadraturePoint = 0;
+                 quadraturePoint < integrationRule.GetNPoints();
+                 ++quadraturePoint) {
+                const mfem::IntegrationPoint &integrationPoint =
+                    integrationRule.IntPoint(quadraturePoint);
+
+                transformation->SetIntPoint(&integrationPoint);
+
+                const mapping::MappingStatus mappingStatus =
+                    domainMapper.EvaluateVolume(
+                        mappingData, *transformation, integrationPoint,
+                        workspace, mappingContext
+                    );
+
+                MFEM_VERIFY(
+                    mappingStatus == mapping::MappingStatus::valid,
+                    "The base mapping is invalid while applying "
+                    "the barotropic-closure displacement action. "
+                    "Element: "
+                        << elementId
+                        << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadraturePoint
+                        << ", status: " << static_cast<int>(mappingStatus)
+                );
+
+                const mapping::MappingStatus variationStatus =
+                    domainMapper.EvaluateVolumeVariation(
+                        mappingData, displacementVariationData, *transformation,
+                        integrationPoint, mappingContext, workspace,
+                        mappingVariation
+                    );
+
+                MFEM_VERIFY(
+                    variationStatus == mapping::MappingStatus::valid,
+                    "The mapping variation is invalid while "
+                    "applying the barotropic-closure "
+                    "displacement action. Element: "
+                        << elementId
+                        << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadraturePoint
+                        << ", status: " << static_cast<int>(variationStatus)
+                );
+
+                densityElement.CalcShape(integrationPoint, densityShape);
+
+                enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
+
+                const double densityValue = elementBaseDensity * densityShape;
+
+                const double enthalpyValue =
+                    elementBaseEnthalpy * enthalpyShape;
+
+                const double closureValue =
+                    densityValue -
+                    barotrope.density_from_enthalpy(enthalpyValue);
+
+                const double geometryActionValue =
+                    closureValue * mappingVariation.weight_variation;
+
+                MFEM_VERIFY(
+                    std::isfinite(closureValue) &&
+                        std::isfinite(geometryActionValue),
+                    "The barotropic-closure displacement action "
+                    "encountered a non-finite quadrature value."
+                );
+
+                elementAction.Add(geometryActionValue, densityShape);
+            }
+
+            if (densityDofTransformation != nullptr) {
+                densityDofTransformation->TransformDual(elementAction);
+            }
+
+            localAction.AddElementVector(densityDofs, elementAction);
+        }
+
+        local_to_true(*f.densityFes, localAction, action);
+    }
+} // namespace mean_field::operators::kernels

libmeanfield/impl/operators/kernels/hydrostatic_equilibrium_kernels.cpp

@@ -0,0 +1,775 @@
+module;
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <mfem.hpp>
+#include <optional>
+
+module mean_field;
+
+import :operators.kernels.hydrostatic_equilibrium;
+
+namespace {
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &trueVector,
+        mfem::Vector &localVector
+    ) {
+        MFEM_VERIFY(
+            trueVector.Size() == finiteElementSpace.GetTrueVSize(),
+            "True vector has the wrong size."
+        );
+
+        localVector.SetSize(finiteElementSpace.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(trueVector, localVector);
+        } else {
+            localVector = trueVector;
+        }
+    }
+
+    void local_to_true(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &localVector,
+        mfem::Vector &trueVector
+    ) {
+        MFEM_VERIFY(
+            localVector.Size() == finiteElementSpace.GetVSize(),
+            "Local vector has the wrong size."
+        );
+
+        trueVector.SetSize(finiteElementSpace.GetTrueVSize());
+
+        trueVector = 0.0;
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->MultTranspose(localVector, trueVector);
+        } else {
+            trueVector = localVector;
+        }
+    }
+
+    void validate_fem(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper
+    ) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "The hydrostatic kernel requires a mesh."
+        );
+
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr, "The hydrostatic kernel requires the "
+                                      "enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "The hydrostatic kernel requires the "
+            "gravity-potential finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes != nullptr, "The hydrostatic kernel requires the "
+                                          "displacement finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "The hydrostatic kernel requires the "
+            "compactification finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "The hydrostatic kernel requires the "
+            "compactification coordinate."
+        );
+
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "The hydrostatic kernel requires the "
+            "quadrature-rule factory."
+        );
+
+        MFEM_VERIFY(
+            f.mesh->Dimension() == 3,
+            "The rigid-rotation hydrostatic kernel "
+            "currently requires a three-dimensional mesh."
+        );
+
+        MFEM_VERIFY(
+            domainMapper.GetDimension() == f.mesh->Dimension(),
+            "The domain-mapper dimension does not match "
+            "the mesh dimension."
+        );
+    }
+
+    const mfem::IntegrationRule &get_hydrostatic_rule(
+        const mean_field::fem::FEM &f,
+        const mfem::FiniteElement &enthalpyElement,
+        const mfem::FiniteElement &potentialElement,
+        const mfem::ElementTransformation &transformation
+    ) {
+        using EnthalpyField =
+            mean_field::field::Field<mean_field::field::Enthalpy>;
+
+        MFEM_VERIFY(
+            enthalpyElement.GetOrder() ==
+                mean_field::field::Enthalpy::Scalar::familyOrder,
+            "The hydrostatic test element does not match "
+            "the registered enthalpy field."
+        );
+
+        MFEM_VERIFY(
+            potentialElement.GetOrder() ==
+                mean_field::field::Gravity::Potential::familyOrder,
+            "The hydrostatic potential element does not "
+            "match the registered gravity-potential field."
+        );
+
+        const auto enthalpyQuery = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EquilibriumEnthalpy>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(), {}, mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const auto gravityQuery = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EquilibriumGravity>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(), {}, mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const auto rotationQuery = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EquilibriumRotation>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(), std::array<int, 1>{2},
+            mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const auto constantQuery = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EquilibriumConstant>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(), {}, mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        int integrationOrder    = 0;
+
+        const auto update_order = [&f, &transformation, &integrationOrder](
+                                      const mean_field::quadrature::Query &query
+                                  ) {
+            const auto rule = f.quadratureFactory->get(
+                query, transformation.GetGeometryType()
+            );
+
+            MFEM_VERIFY(
+                rule.integration_rule != nullptr,
+                "The quadrature policy did not return "
+                "a hydrostatic-equilibrium rule."
+            );
+
+            integrationOrder =
+                std::max(integrationOrder, rule.resolution.order);
+        };
+
+        update_order(enthalpyQuery);
+        update_order(gravityQuery);
+        update_order(rotationQuery);
+        update_order(constantQuery);
+
+        return mfem::IntRules.Get(
+            transformation.GetGeometryType(), integrationOrder
+        );
+    }
+
+    struct HydrostaticAssemblyRequest {
+        const mean_field::physics::RigidRotation *rotation{nullptr};
+
+        const mfem::Vector *baseEnthalpyTrue{nullptr};
+        const mfem::Vector *basePotentialTrue{nullptr};
+
+        const mfem::Vector *enthalpyVariationTrue{nullptr};
+        const mfem::Vector *potentialVariationTrue{nullptr};
+        const mfem::Vector *displacementVariationTrue{nullptr};
+
+        double bernoulliConstant{0.0};
+        double constantVariation{0.0};
+
+        bool buildResidual{false};
+    };
+
+    void assemble_hydrostatic_form(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper,
+        const mfem::Vector &displacementTrue,
+        const HydrostaticAssemblyRequest &request,
+        mfem::Vector &result
+    ) {
+        validate_fem(f, domainMapper);
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == f.displacementFes->GetTrueVSize(),
+            "The hydrostatic displacement vector has "
+            "the wrong size."
+        );
+
+        MFEM_VERIFY(
+            std::isfinite(request.bernoulliConstant),
+            "The Bernoulli constant is non-finite."
+        );
+
+        MFEM_VERIFY(
+            std::isfinite(request.constantVariation),
+            "The Bernoulli-constant variation is non-finite."
+        );
+
+        const bool requiresBaseState =
+            request.buildResidual ||
+            request.displacementVariationTrue != nullptr;
+
+        if (requiresBaseState) {
+            MFEM_VERIFY(
+                request.rotation != nullptr,
+                "The hydrostatic residual or geometry "
+                "action requires the rotation model."
+            );
+
+            MFEM_VERIFY(
+                request.baseEnthalpyTrue != nullptr,
+                "The hydrostatic residual or geometry "
+                "action requires the base enthalpy."
+            );
+
+            MFEM_VERIFY(
+                request.basePotentialTrue != nullptr,
+                "The hydrostatic residual or geometry "
+                "action requires the base potential."
+            );
+        }
+
+        if (request.baseEnthalpyTrue != nullptr) {
+            MFEM_VERIFY(
+                request.baseEnthalpyTrue->Size() ==
+                    f.enthalpyFes->GetTrueVSize(),
+                "The base enthalpy vector has the wrong size."
+            );
+        }
+
+        if (request.basePotentialTrue != nullptr) {
+            MFEM_VERIFY(
+                request.basePotentialTrue->Size() ==
+                    f.gravityPotentialFes->GetTrueVSize(),
+                "The base potential vector has the wrong size."
+            );
+        }
+
+        if (request.enthalpyVariationTrue != nullptr) {
+            MFEM_VERIFY(
+                request.enthalpyVariationTrue->Size() ==
+                    f.enthalpyFes->GetTrueVSize(),
+                "The enthalpy variation has the wrong size."
+            );
+        }
+
+        if (request.potentialVariationTrue != nullptr) {
+            MFEM_VERIFY(
+                request.potentialVariationTrue->Size() ==
+                    f.gravityPotentialFes->GetTrueVSize(),
+                "The potential variation has the wrong size."
+            );
+        }
+
+        if (request.displacementVariationTrue != nullptr) {
+            MFEM_VERIFY(
+                request.displacementVariationTrue->Size() ==
+                    f.displacementFes->GetTrueVSize(),
+                "The displacement variation has the wrong size."
+            );
+        }
+
+        mfem::Vector displacementLocal;
+        true_to_local(*f.displacementFes, displacementTrue, displacementLocal);
+
+        mfem::Vector baseEnthalpyLocal;
+        mfem::Vector basePotentialLocal;
+        mfem::Vector enthalpyVariationLocal;
+        mfem::Vector potentialVariationLocal;
+        mfem::Vector displacementVariationLocal;
+
+        if (request.baseEnthalpyTrue != nullptr) {
+            true_to_local(
+                *f.enthalpyFes, *request.baseEnthalpyTrue, baseEnthalpyLocal
+            );
+        }
+
+        if (request.basePotentialTrue != nullptr) {
+            true_to_local(
+                *f.gravityPotentialFes, *request.basePotentialTrue,
+                basePotentialLocal
+            );
+        }
+
+        if (request.enthalpyVariationTrue != nullptr) {
+            true_to_local(
+                *f.enthalpyFes, *request.enthalpyVariationTrue,
+                enthalpyVariationLocal
+            );
+        }
+
+        if (request.potentialVariationTrue != nullptr) {
+            true_to_local(
+                *f.gravityPotentialFes, *request.potentialVariationTrue,
+                potentialVariationLocal
+            );
+        }
+
+        if (request.displacementVariationTrue != nullptr) {
+            true_to_local(
+                *f.displacementFes, *request.displacementVariationTrue,
+                displacementVariationLocal
+            );
+        }
+
+        mfem::Vector localResult(f.enthalpyFes->GetVSize());
+
+        localResult = 0.0;
+
+        mean_field::mapping::DomainMapperStateless::Workspace workspace(
+            f.mesh->Dimension()
+        );
+
+        mfem::Array<int> enthalpyDofs;
+        mfem::Array<int> potentialDofs;
+        mfem::Array<int> displacementDofs;
+        mfem::Array<int> compactificationDofs;
+
+        mfem::Vector elementBaseEnthalpy;
+        mfem::Vector elementBasePotential;
+        mfem::Vector elementEnthalpyVariation;
+        mfem::Vector elementPotentialVariation;
+        mfem::Vector elementDisplacement;
+        mfem::Vector elementDisplacementVariation;
+        mfem::Vector elementCompactification;
+        mfem::Vector elementResult;
+
+        mfem::Vector enthalpyShape;
+        mfem::Vector potentialShape;
+
+        const int vacuumAttribute = domainMapper.GetVacuumElementAttribute();
+
+        for (int elementId = 0; elementId < f.mesh->GetNE(); ++elementId) {
+            mfem::ElementTransformation *transformation =
+                f.mesh->GetElementTransformation(elementId);
+
+            MFEM_VERIFY(
+                transformation != nullptr,
+                "The hydrostatic kernel received a null "
+                "element transformation."
+            );
+
+            if (transformation->Attribute == vacuumAttribute) {
+                continue;
+            }
+
+            const mfem::FiniteElement &enthalpyElement =
+                *f.enthalpyFes->GetFE(elementId);
+
+            const mfem::FiniteElement &potentialElement =
+                *f.gravityPotentialFes->GetFE(elementId);
+
+            const mfem::FiniteElement &displacementElement =
+                *f.displacementFes->GetFE(elementId);
+
+            const mfem::FiniteElement &compactificationElement =
+                *f.compactificationFes->GetFE(elementId);
+
+            mfem::DofTransformation *enthalpyDofTransformation =
+                f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
+
+            mfem::DofTransformation *potentialDofTransformation =
+                f.gravityPotentialFes->GetElementDofs(elementId, potentialDofs);
+
+            mfem::DofTransformation *displacementDofTransformation =
+                f.displacementFes->GetElementVDofs(elementId, displacementDofs);
+
+            mfem::DofTransformation *compactificationDofTransformation =
+                f.compactificationFes->GetElementDofs(
+                    elementId, compactificationDofs
+                );
+
+            displacementLocal.GetSubVector(
+                displacementDofs, elementDisplacement
+            );
+
+            f.compactificationCoordinate->GetSubVector(
+                compactificationDofs, elementCompactification
+            );
+
+            if (request.baseEnthalpyTrue != nullptr) {
+                baseEnthalpyLocal.GetSubVector(
+                    enthalpyDofs, elementBaseEnthalpy
+                );
+            }
+
+            if (request.basePotentialTrue != nullptr) {
+                basePotentialLocal.GetSubVector(
+                    potentialDofs, elementBasePotential
+                );
+            }
+
+            if (request.enthalpyVariationTrue != nullptr) {
+                enthalpyVariationLocal.GetSubVector(
+                    enthalpyDofs, elementEnthalpyVariation
+                );
+            }
+
+            if (request.potentialVariationTrue != nullptr) {
+                potentialVariationLocal.GetSubVector(
+                    potentialDofs, elementPotentialVariation
+                );
+            }
+
+            if (request.displacementVariationTrue != nullptr) {
+                displacementVariationLocal.GetSubVector(
+                    displacementDofs, elementDisplacementVariation
+                );
+            }
+
+            if (enthalpyDofTransformation != nullptr) {
+                if (request.baseEnthalpyTrue != nullptr) {
+                    enthalpyDofTransformation->InvTransformPrimal(
+                        elementBaseEnthalpy
+                    );
+                }
+
+                if (request.enthalpyVariationTrue != nullptr) {
+                    enthalpyDofTransformation->InvTransformPrimal(
+                        elementEnthalpyVariation
+                    );
+                }
+            }
+
+            if (potentialDofTransformation != nullptr) {
+                if (request.basePotentialTrue != nullptr) {
+                    potentialDofTransformation->InvTransformPrimal(
+                        elementBasePotential
+                    );
+                }
+
+                if (request.potentialVariationTrue != nullptr) {
+                    potentialDofTransformation->InvTransformPrimal(
+                        elementPotentialVariation
+                    );
+                }
+            }
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacement
+                );
+
+                if (request.displacementVariationTrue != nullptr) {
+                    displacementDofTransformation->InvTransformPrimal(
+                        elementDisplacementVariation
+                    );
+                }
+            }
+
+            if (compactificationDofTransformation != nullptr) {
+                compactificationDofTransformation->InvTransformPrimal(
+                    elementCompactification
+                );
+            }
+
+            const mean_field::mapping::ElementDisplacementData
+                displacementData = mean_field::mapping::
+                    ElementDisplacementDataFromElementVDofs(
+                        displacementElement, elementDisplacement
+                    );
+
+            const mean_field::mapping::ElementCompactificationData
+                compactificationData(
+                    compactificationElement, elementCompactification
+                );
+
+            const mean_field::mapping::ElementMappingData mappingData{
+                .displacement     = displacementData,
+                .compactification = compactificationData
+            };
+
+            std::optional<mean_field::mapping::ElementDisplacementData>
+                displacementVariationData;
+
+            if (request.displacementVariationTrue != nullptr) {
+                displacementVariationData.emplace(
+                    mean_field::mapping::
+                        ElementDisplacementDataFromElementVDofs(
+                            displacementElement, elementDisplacementVariation
+                        )
+                );
+            }
+
+            elementResult.SetSize(enthalpyElement.GetDof());
+
+            elementResult = 0.0;
+
+            enthalpyShape.SetSize(enthalpyElement.GetDof());
+
+            potentialShape.SetSize(potentialElement.GetDof());
+
+            const mfem::IntegrationRule &integrationRule = get_hydrostatic_rule(
+                f, enthalpyElement, potentialElement, *transformation
+            );
+
+            for (int quadraturePoint = 0;
+                 quadraturePoint < integrationRule.GetNPoints();
+                 ++quadraturePoint) {
+                const mfem::IntegrationPoint &integrationPoint =
+                    integrationRule.IntPoint(quadraturePoint);
+
+                transformation->SetIntPoint(&integrationPoint);
+
+                mean_field::mapping::VolumeMappingContext mappingContext;
+
+                const mean_field::mapping::MappingStatus mappingStatus =
+                    domainMapper.EvaluateVolume(
+                        mappingData, *transformation, integrationPoint,
+                        workspace, mappingContext
+                    );
+
+                MFEM_VERIFY(
+                    mappingStatus == mean_field::mapping::MappingStatus::valid,
+                    "The base mapping is invalid in the "
+                    "hydrostatic kernel. Element: "
+                        << elementId
+                        << ", quadrature point: " << quadraturePoint
+                        << ", status: " << static_cast<int>(mappingStatus)
+                );
+
+                enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
+
+                potentialElement.CalcShape(integrationPoint, potentialShape);
+
+                double baseIntegrand = 0.0;
+
+                if (requiresBaseState) {
+                    const double enthalpyValue =
+                        elementBaseEnthalpy * enthalpyShape;
+
+                    const double potentialValue =
+                        elementBasePotential * potentialShape;
+
+                    const double rotationPotential =
+                        request.rotation->potential(
+                            mappingContext.mapping.physical_position
+                        );
+
+                    baseIntegrand = enthalpyValue + potentialValue -
+                                    rotationPotential -
+                                    request.bernoulliConstant;
+                }
+
+                if (request.buildResidual) {
+                    elementResult.Add(
+                        mappingContext.quadrature.weight * baseIntegrand,
+                        enthalpyShape
+                    );
+
+                    continue;
+                }
+
+                double materialVariation = -request.constantVariation;
+
+                if (request.enthalpyVariationTrue != nullptr) {
+                    materialVariation +=
+                        elementEnthalpyVariation * enthalpyShape;
+                }
+
+                if (request.potentialVariationTrue != nullptr) {
+                    materialVariation +=
+                        elementPotentialVariation * potentialShape;
+                }
+
+                double weightedVariation =
+                    mappingContext.quadrature.weight * materialVariation;
+
+                if (request.displacementVariationTrue != nullptr) {
+                    mean_field::mapping::VolumeMappingVariation
+                        mappingVariation;
+
+                    const mean_field::mapping::MappingStatus variationStatus =
+                        domainMapper.EvaluateVolumeVariation(
+                            mappingData, *displacementVariationData,
+                            *transformation, integrationPoint, mappingContext,
+                            workspace, mappingVariation
+                        );
+
+                    MFEM_VERIFY(
+                        variationStatus ==
+                            mean_field::mapping::MappingStatus::valid,
+                        "The mapping variation is invalid "
+                        "in the hydrostatic kernel."
+                    );
+
+                    const double rotationVariation =
+                        request.rotation->potential_directional_derivative(
+                            mappingContext.mapping.physical_position,
+                            mappingVariation.mapping.physical_position_variation
+                        );
+
+                    weightedVariation +=
+                        baseIntegrand * mappingVariation.weight_variation -
+                        rotationVariation * mappingContext.quadrature.weight;
+                }
+
+                elementResult.Add(weightedVariation, enthalpyShape);
+            }
+
+            if (enthalpyDofTransformation != nullptr) {
+                enthalpyDofTransformation->TransformDual(elementResult);
+            }
+
+            localResult.AddElementVector(enthalpyDofs, elementResult);
+        }
+
+        local_to_true(*f.enthalpyFes, localResult, result);
+    }
+} // namespace
+
+namespace mean_field::operators::kernels {
+    void apply_hydrostatic_equilibrium(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::RigidRotation &rotation,
+        const mfem::Vector &enthalpyTrue,
+        const mfem::Vector &potentialTrue,
+        const mfem::Vector &displacementTrue,
+        const double bernoulliConstant,
+        mfem::Vector &residual
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.rotation          = &rotation;
+        request.baseEnthalpyTrue  = &enthalpyTrue;
+        request.basePotentialTrue = &potentialTrue;
+        request.bernoulliConstant = bernoulliConstant;
+        request.buildResidual     = true;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, displacementTrue, request, residual
+        );
+    }
+
+    void apply_hydrostatic_equilibrium_enthalpy_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const mfem::Vector &enthalpyVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.enthalpyVariationTrue = &enthalpyVariationTrue;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, displacementTrue, request, action
+        );
+    }
+
+    void apply_hydrostatic_equilibrium_potential_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const mfem::Vector &potentialVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.potentialVariationTrue = &potentialVariationTrue;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, displacementTrue, request, action
+        );
+    }
+
+    void apply_hydrostatic_equilibrium_constant_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const double constantVariation,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &action
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.constantVariation = constantVariation;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, displacementTrue, request, action
+        );
+    }
+
+    void apply_hydrostatic_equilibrium_displacement_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::RigidRotation &rotation,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &basePotentialTrue,
+        const mfem::Vector &baseDisplacementTrue,
+        const double baseBernoulliConstant,
+        const mfem::Vector &displacementVariationTrue,
+        mfem::Vector &action
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.rotation                  = &rotation;
+        request.baseEnthalpyTrue          = &baseEnthalpyTrue;
+        request.basePotentialTrue         = &basePotentialTrue;
+        request.displacementVariationTrue = &displacementVariationTrue;
+        request.bernoulliConstant         = baseBernoulliConstant;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, baseDisplacementTrue, request, action
+        );
+    }
+
+    void apply_hydrostatic_equilibrium_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::RigidRotation &rotation,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &basePotentialTrue,
+        const mfem::Vector &baseDisplacementTrue,
+        const double baseBernoulliConstant,
+        const mfem::Vector &enthalpyVariationTrue,
+        const mfem::Vector &potentialVariationTrue,
+        const double constantVariation,
+        const mfem::Vector &displacementVariationTrue,
+        mfem::Vector &action
+    ) {
+        HydrostaticAssemblyRequest request;
+
+        request.rotation                  = &rotation;
+        request.baseEnthalpyTrue          = &baseEnthalpyTrue;
+        request.basePotentialTrue         = &basePotentialTrue;
+        request.enthalpyVariationTrue     = &enthalpyVariationTrue;
+        request.potentialVariationTrue    = &potentialVariationTrue;
+        request.displacementVariationTrue = &displacementVariationTrue;
+        request.bernoulliConstant         = baseBernoulliConstant;
+        request.constantVariation         = constantVariation;
+
+        assemble_hydrostatic_form(
+            f, domainMapper, baseDisplacementTrue, request, action
+        );
+    }
+} // namespace mean_field::operators::kernels

libmeanfield/impl/operators/kernels/pressure_force_kernels.cpp

@@ -0,0 +1,464 @@
+module;
+
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include <mfem.hpp>
+
+module mean_field;
+
+import :operators.kernels.pressure_force;
+
+namespace {
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &trueVector,
+        mfem::Vector &localVector
+    ) {
+        MFEM_VERIFY(
+            trueVector.Size() == finiteElementSpace.GetTrueVSize(),
+            "The pressure-force true vector has the wrong size."
+        );
+
+        localVector.SetSize(finiteElementSpace.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(trueVector, localVector);
+        } else {
+            localVector = trueVector;
+        }
+    }
+
+    void local_to_true(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &localVector,
+        mfem::Vector &trueVector
+    ) {
+        MFEM_VERIFY(
+            localVector.Size() == finiteElementSpace.GetVSize(),
+            "The pressure-force local vector has the wrong size."
+        );
+
+        trueVector.SetSize(finiteElementSpace.GetTrueVSize());
+        trueVector = 0.0;
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->MultTranspose(localVector, trueVector);
+        } else {
+            trueVector = localVector;
+        }
+    }
+
+    [[nodiscard]] int vector_dof_index(
+        const mfem::Ordering::Type ordering,
+        const int scalarDof,
+        const int component,
+        const int scalarDofCount,
+        const int dimension
+    ) {
+        if (ordering == mfem::Ordering::byNODES) {
+            return scalarDof + component * scalarDofCount;
+        }
+
+        if (ordering == mfem::Ordering::byVDIM) {
+            return component + scalarDof * dimension;
+        }
+        MFEM_ABORT("The displacement space uses an unsupported ordering.");
+        return -1;
+    }
+
+    [[nodiscard]] int get_pressure_extra_order(
+        const mean_field::physics::PolytropicBarotrope &barotrope
+    ) {
+        /*
+         * Pressure has the enthalpy dependence
+         *
+         *     P(h) proportional to h^(n + 1).
+         *
+         * The registered enthalpy operand already contributes one factor
+         * of the enthalpy polynomial order. The remaining dynamic
+         * contribution is therefore n times that order.
+         */
+        const double extraOrder =
+            barotrope.polytropic_index() *
+            static_cast<double>(
+                mean_field::field::Enthalpy::Scalar::familyOrder
+            );
+
+        MFEM_VERIFY(
+            std::isfinite(extraOrder) && extraOrder >= 0.0 &&
+                extraOrder <=
+                    static_cast<double>(std::numeric_limits<int>::max()),
+            "The pressure EOS effective polynomial order is invalid."
+        );
+
+        return static_cast<int>(std::ceil(extraOrder));
+    }
+
+    [[nodiscard]] const mfem::IntegrationRule &get_pressure_force_rule(
+        const mean_field::fem::FEM &f,
+        const mean_field::physics::PolytropicBarotrope &barotrope,
+        const mfem::FiniteElement &enthalpyElement,
+        const mfem::FiniteElement &displacementElement,
+        const mfem::ElementTransformation &transformation
+    ) {
+        using EnthalpyField =
+            mean_field::field::Field<mean_field::field::Enthalpy>;
+
+        MFEM_VERIFY(
+            enthalpyElement.GetOrder() ==
+                mean_field::field::Enthalpy::Scalar::familyOrder,
+            "The pressure-force enthalpy element does not match the "
+            "registered enthalpy field."
+        );
+
+        MFEM_VERIFY(
+            displacementElement.GetOrder() ==
+                mean_field::field::Displacement::Vector::familyOrder,
+            "The pressure-force test element does not match the "
+            "registered displacement field."
+        );
+
+        const mean_field::quadrature::Query query = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::PressureForce>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(),
+            std::array<int, 1>{get_pressure_extra_order(barotrope)},
+            mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const mean_field::quadrature::MfemRule rule =
+            f.quadratureFactory->get(query, transformation.GetGeometryType());
+
+        MFEM_VERIFY(
+            rule.integration_rule != nullptr,
+            "The quadrature policy did not return a pressure-force "
+            "integration rule."
+        );
+
+        return *rule.integration_rule;
+    }
+
+    void validate_inputs(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper,
+        const mfem::Vector &enthalpyTrue,
+        const mfem::Vector &displacementTrue
+    ) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "The pressure-force kernel requires a mesh."
+        );
+
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr,
+            "The pressure-force kernel requires the enthalpy "
+            "finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "The pressure-force kernel requires the displacement "
+            "finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "The pressure-force kernel requires the compactification "
+            "finite-element space."
+        );
+
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "The pressure-force kernel requires the compactification "
+            "coordinate."
+        );
+
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "The pressure-force kernel requires the quadrature "
+            "rule factory."
+        );
+
+        MFEM_VERIFY(
+            enthalpyTrue.Size() == f.enthalpyFes->GetTrueVSize(),
+            "The pressure-force enthalpy vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == f.displacementFes->GetTrueVSize(),
+            "The pressure-force displacement vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            domainMapper.GetDimension() == f.mesh->Dimension(),
+            "The pressure-force domain-mapper dimension does not match "
+            "the mesh dimension."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes->GetVDim() == f.mesh->Dimension(),
+            "The displacement vector dimension does not match the "
+            "mesh dimension."
+        );
+
+        MFEM_VERIFY(
+            f.displacementFes->GetOrdering() == mfem::Ordering::byNODES,
+            "The pressure-force kernel requires the registered byNODES "
+            "displacement ordering."
+        );
+    }
+} // namespace
+
+namespace mean_field::operators::kernels {
+    void apply_pressure_force_residual(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope,
+        const mfem::Vector &enthalpyTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &residualTrue
+    ) {
+        validate_inputs(f, domainMapper, enthalpyTrue, displacementTrue);
+
+        mfem::Vector enthalpyLocal;
+        mfem::Vector displacementLocal;
+
+        true_to_local(*f.enthalpyFes, enthalpyTrue, enthalpyLocal);
+
+        true_to_local(*f.displacementFes, displacementTrue, displacementLocal);
+
+        mfem::Vector localResidual(f.displacementFes->GetVSize());
+        localResidual = 0.0;
+
+        mapping::DomainMapperStateless::Workspace workspace(
+            f.mesh->Dimension()
+        );
+
+        mfem::Array<int> enthalpyDofs;
+        mfem::Array<int> displacementDofs;
+        mfem::Array<int> compactificationDofs;
+
+        mfem::Vector elementEnthalpy;
+        mfem::Vector elementDisplacement;
+        mfem::Vector elementCompactification;
+        mfem::Vector elementResidual;
+        mfem::Vector enthalpyShape;
+
+        mfem::DenseMatrix displacementDShapeReference;
+        mfem::DenseMatrix displacementDShapePhysical;
+
+        mapping::VolumeMappingContext mappingContext;
+
+        const int dimension       = f.mesh->Dimension();
+        const int vacuumAttribute = domainMapper.GetVacuumElementAttribute();
+
+        const mfem::Ordering::Type displacementOrdering =
+            f.displacementFes->GetOrdering();
+
+        for (int elementId = 0; elementId < f.mesh->GetNE(); ++elementId) {
+            mfem::ElementTransformation *transformation =
+                f.mesh->GetElementTransformation(elementId);
+
+            MFEM_VERIFY(
+                transformation != nullptr,
+                "The pressure-force kernel received a null element "
+                "transformation."
+            );
+
+            /*
+             * Skip vacuum before constructing or evaluating any mapping
+             * data for the element.
+             */
+            if (transformation->Attribute == vacuumAttribute) {
+                continue;
+            }
+
+            const mfem::FiniteElement &enthalpyElement =
+                *f.enthalpyFes->GetFE(elementId);
+
+            const mfem::FiniteElement &displacementElement =
+                *f.displacementFes->GetFE(elementId);
+
+            const mfem::FiniteElement &compactificationElement =
+                *f.compactificationFes->GetFE(elementId);
+
+            mfem::DofTransformation *enthalpyDofTransformation =
+                f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
+
+            mfem::DofTransformation *displacementDofTransformation =
+                f.displacementFes->GetElementVDofs(elementId, displacementDofs);
+
+            mfem::DofTransformation *compactificationDofTransformation =
+                f.compactificationFes->GetElementDofs(
+                    elementId, compactificationDofs
+                );
+
+            enthalpyLocal.GetSubVector(enthalpyDofs, elementEnthalpy);
+
+            displacementLocal.GetSubVector(
+                displacementDofs, elementDisplacement
+            );
+
+            f.compactificationCoordinate->GetSubVector(
+                compactificationDofs, elementCompactification
+            );
+
+            if (enthalpyDofTransformation != nullptr) {
+                enthalpyDofTransformation->InvTransformPrimal(elementEnthalpy);
+            }
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacement
+                );
+            }
+
+            if (compactificationDofTransformation != nullptr) {
+                compactificationDofTransformation->InvTransformPrimal(
+                    elementCompactification
+                );
+            }
+
+            const mapping::ElementDisplacementData displacementData =
+                mapping::ElementDisplacementDataFromElementVDofs(
+                    displacementElement, elementDisplacement
+                );
+
+            const mapping::ElementCompactificationData compactificationData(
+                compactificationElement, elementCompactification
+            );
+
+            const mapping::ElementMappingData mappingData{
+                .displacement     = displacementData,
+                .compactification = compactificationData
+            };
+
+            const int scalarDisplacementDofCount = displacementElement.GetDof();
+
+            MFEM_VERIFY(
+                displacementDofs.Size() ==
+                    scalarDisplacementDofCount * dimension,
+                "The pressure-force element displacement vector has "
+                "the wrong size."
+            );
+
+            enthalpyShape.SetSize(enthalpyElement.GetDof());
+
+            displacementDShapeReference.SetSize(
+                scalarDisplacementDofCount, dimension
+            );
+
+            displacementDShapePhysical.SetSize(
+                scalarDisplacementDofCount, dimension
+            );
+
+            elementResidual.SetSize(displacementDofs.Size());
+            elementResidual = 0.0;
+
+            const mfem::IntegrationRule &integrationRule =
+                get_pressure_force_rule(
+                    f, barotrope, enthalpyElement, displacementElement,
+                    *transformation
+                );
+
+            for (int quadratureIndex = 0;
+                 quadratureIndex < integrationRule.GetNPoints();
+                 ++quadratureIndex) {
+                const mfem::IntegrationPoint &integrationPoint =
+                    integrationRule.IntPoint(quadratureIndex);
+
+                transformation->SetIntPoint(&integrationPoint);
+
+                const mapping::MappingStatus mappingStatus =
+                    domainMapper.EvaluateVolume(
+                        mappingData, *transformation, integrationPoint,
+                        workspace, mappingContext
+                    );
+
+                MFEM_VERIFY(
+                    mappingStatus == mapping::MappingStatus::valid,
+                    "Stateless mapping failed in the pressure-force "
+                    "kernel. Element: "
+                        << elementId
+                        << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadratureIndex
+                        << ", status: " << static_cast<int>(mappingStatus)
+                );
+
+                enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
+
+                const double enthalpyValue = elementEnthalpy * enthalpyShape;
+
+                const double pressureValue =
+                    barotrope.pressure_from_enthalpy(enthalpyValue);
+
+                displacementElement.CalcDShape(
+                    integrationPoint, displacementDShapeReference
+                );
+
+                /*
+                 * Row i of DShape is grad_reference(N_i). Multiplication
+                 * by the complete inverse element Jacobian gives
+                 *
+                 *     grad_physical(N_i)
+                 *       = grad_reference(N_i) J^{-1}.
+                 */
+                mfem::Mult(
+                    displacementDShapeReference,
+                    mappingContext.quadrature.J_inv, displacementDShapePhysical
+                );
+
+                const double weightedPressure =
+                    pressureValue * mappingContext.quadrature.weight;
+
+                MFEM_VERIFY(
+                    std::isfinite(pressureValue) &&
+                        std::isfinite(weightedPressure),
+                    "The pressure-force kernel encountered a non-finite "
+                    "quadrature value."
+                );
+
+                /*
+                 * For the vector basis N_i e_c,
+                 *
+                 *     div(N_i e_c) = partial_c N_i.
+                 *
+                 * Therefore
+                 *
+                 *     R_(i,c)
+                 *       = -integral P partial_c N_i dV.
+                 */
+                for (int scalarDof = 0; scalarDof < scalarDisplacementDofCount;
+                     ++scalarDof) {
+                    for (int component = 0; component < dimension;
+                         ++component) {
+                        const int vectorDof = vector_dof_index(
+                            displacementOrdering, scalarDof, component,
+                            scalarDisplacementDofCount, dimension
+                        );
+
+                        elementResidual(vectorDof) -=
+                            weightedPressure *
+                            displacementDShapePhysical(scalarDof, component);
+                    }
+                }
+            }
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->TransformDual(elementResidual);
+            }
+
+            localResidual.AddElementVector(displacementDofs, elementResidual);
+        }
+
+        local_to_true(*f.displacementFes, localResidual, residualTrue);
+    }
+} // namespace mean_field::operators::kernels

libmeanfield/impl/operators/prepared_barotropic_closure.cpp

@@ -0,0 +1,718 @@
+module;
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <mfem.hpp>
+
+module mean_field;
+
+import :operators.prepared_barotropic_closure;
+
+namespace {
+    int get_density_size(const mean_field::fem::FEM &f) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "PreparedBarotropicClosureOperator requires the "
+            "density finite-element space."
+        );
+
+        return f.densityFes->GetTrueVSize();
+    }
+
+    int get_enthalpy_size(const mean_field::fem::FEM &f) {
+        MFEM_VERIFY(
+            f.enthalpyFes != nullptr,
+            "PreparedBarotropicClosureOperator requires the "
+            "enthalpy finite-element space."
+        );
+
+        return f.enthalpyFes->GetTrueVSize();
+    }
+
+    void validate_finite_vector(
+        const mfem::Vector &vector,
+        const char *message
+    ) {
+        for (int i = 0; i < vector.Size(); ++i) {
+            MFEM_VERIFY(std::isfinite(vector(i)), message);
+        }
+    }
+
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &trueVector,
+        mfem::Vector &localVector
+    ) {
+        MFEM_VERIFY(
+            trueVector.Size() == finiteElementSpace.GetTrueVSize(),
+            "True vector has the wrong size."
+        );
+
+        localVector.SetSize(finiteElementSpace.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(trueVector, localVector);
+        } else {
+            localVector = trueVector;
+        }
+    }
+
+    void local_to_true(
+        const mfem::ParFiniteElementSpace &finiteElementSpace,
+        const mfem::Vector &localVector,
+        mfem::Vector &trueVector
+    ) {
+        MFEM_VERIFY(
+            localVector.Size() == finiteElementSpace.GetVSize(),
+            "Local vector has the wrong size."
+        );
+
+        trueVector.SetSize(finiteElementSpace.GetTrueVSize());
+        trueVector = 0.0;
+
+        const mfem::Operator *prolongation =
+            finiteElementSpace.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->MultTranspose(localVector, trueVector);
+        } else {
+            trueVector = localVector;
+        }
+    }
+
+    int get_eos_extra_order(
+        const mean_field::physics::PolytropicBarotrope &barotrope
+    ) {
+        const double extraOrder =
+            (barotrope.polytropic_index() - 1.0) *
+            static_cast<double>(
+                mean_field::field::Enthalpy::Scalar::familyOrder
+            );
+
+        MFEM_VERIFY(
+            std::isfinite(extraOrder) && extraOrder >= 0.0 &&
+                extraOrder <=
+                    static_cast<double>(std::numeric_limits<int>::max()),
+            "The EOS effective polynomial order is invalid."
+        );
+
+        return static_cast<int>(std::ceil(extraOrder));
+    }
+
+    const mfem::IntegrationRule &get_eos_rule(
+        const mean_field::fem::FEM &f,
+        const mean_field::physics::PolytropicBarotrope &barotrope,
+        const mfem::FiniteElement &densityElement,
+        const mfem::FiniteElement &enthalpyElement,
+        const mfem::ElementTransformation &transformation
+    ) {
+        using EnthalpyField =
+            mean_field::field::Field<mean_field::field::Enthalpy>;
+
+        MFEM_VERIFY(
+            densityElement.GetOrder() ==
+                mean_field::field::Density::Scalar::familyOrder,
+            "The prepared EOS test element does not match "
+            "the registered density field."
+        );
+
+        MFEM_VERIFY(
+            enthalpyElement.GetOrder() ==
+                mean_field::field::Enthalpy::Scalar::familyOrder,
+            "The prepared EOS trial element does not match "
+            "the registered enthalpy field."
+        );
+
+        const mean_field::quadrature::Query query = EnthalpyField::make_query<
+            mean_field::field::Enthalpy::Form::EosClosureSource>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(),
+            std::array<int, 1>{get_eos_extra_order(barotrope)},
+            mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        const auto resolution =
+            f.quadratureFactory->get(query, transformation.GetGeometryType());
+
+        MFEM_VERIFY(
+            resolution.integration_rule != nullptr,
+            "The quadrature policy did not return a prepared "
+            "EOS-closure integration rule."
+        );
+
+        return *resolution.integration_rule;
+    }
+} // namespace
+
+namespace mean_field::operators {
+    PreparedBarotropicClosureOperator::PreparedBarotropicClosureOperator(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const physics::PolytropicBarotrope &barotrope
+    )
+        : mfem::Operator(
+              f.densityFes->GetTrueVSize(),
+              f.densityFes->GetTrueVSize() + f.enthalpyFes->GetTrueVSize() +
+                  f.displacementFes->GetTrueVSize()
+          ),
+          m_fem(f),
+          m_domainMapper(domainMapper),
+          m_barotrope(barotrope),
+          m_densitySize(f.densityFes->GetTrueVSize()),
+          m_enthalpySize(f.enthalpyFes->GetTrueVSize()) {
+        MFEM_VERIFY(
+            m_fem.densityFes != nullptr,
+            "PreparedBarotropicClosureOperator requires "
+            "a density finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_fem.enthalpyFes != nullptr,
+            "PreparedBarotropicClosureOperator requires "
+            "an enthalpy finite-element space."
+        );
+
+        MFEM_VERIFY(
+            m_fem.displacementFes != nullptr,
+            "PreparedBarotropicClosureOperator requires "
+            "a displacement finite-element space."
+        );
+    }
+
+    void PreparedBarotropicClosureOperator::Prepare(
+        const mfem::Vector &baseDensityTrue,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &displacementTrue
+    ) {
+        MFEM_VERIFY(
+            baseDensityTrue.Size() == m_densitySize,
+            "PreparedBarotropicClosureOperator received a "
+            "base-density vector with the wrong size."
+        );
+
+        MFEM_VERIFY(
+            baseEnthalpyTrue.Size() == m_enthalpySize,
+            "PreparedBarotropicClosureOperator received a "
+            "base-enthalpy vector with the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == m_fem.displacementFes->GetTrueVSize(),
+            "PreparedBarotropicClosureOperator received a "
+            "displacement vector with the wrong size."
+        );
+        MFEM_VERIFY(
+            baseDensityTrue.Size() == m_fem.densityFes->GetTrueVSize(),
+            "The base density true vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            baseEnthalpyTrue.Size() == m_fem.enthalpyFes->GetTrueVSize(),
+            "The base enthalpy true vector has the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementTrue.Size() == m_fem.displacementFes->GetTrueVSize(),
+            "The base displacement true vector has the wrong size."
+        );
+
+        validate_finite_vector(
+            baseDensityTrue, "PreparedBarotropicClosureOperator received a "
+                             "non-finite base-density value."
+        );
+
+        validate_finite_vector(
+            baseEnthalpyTrue, "PreparedBarotropicClosureOperator received a "
+                              "non-finite base-enthalpy value."
+        );
+
+        validate_finite_vector(
+            displacementTrue, "PreparedBarotropicClosureOperator received a "
+                              "non-finite displacement value."
+        );
+
+        m_isPrepared = false;
+        m_elements.clear();
+        m_elements.reserve(m_fem.mesh->GetNE());
+
+        mfem::Vector baseDensityLocal;
+        mfem::Vector baseEnthalpyLocal;
+        mfem::Vector displacementLocal;
+
+        true_to_local(*m_fem.densityFes, baseDensityTrue, baseDensityLocal);
+
+        true_to_local(*m_fem.enthalpyFes, baseEnthalpyTrue, baseEnthalpyLocal);
+
+        true_to_local(
+            *m_fem.displacementFes, displacementTrue, displacementLocal
+        );
+
+        mapping::DomainMapperStateless::Workspace workspace(
+            m_fem.mesh->Dimension()
+        );
+
+        mfem::Array<int> displacementDofs;
+        mfem::Array<int> compactificationDofs;
+
+        mfem::Vector elementBaseDensity;
+        mfem::Vector elementBaseEnthalpy;
+        mfem::Vector elementDisplacement;
+        mfem::Vector elementCompactification;
+
+        mfem::Vector densityShape;
+        mfem::Vector enthalpyShape;
+
+        const int vacuumAttribute = m_domainMapper.GetVacuumElementAttribute();
+
+        for (int elementId = 0; elementId < m_fem.mesh->GetNE(); ++elementId) {
+            mfem::ElementTransformation *transformation =
+                m_fem.mesh->GetElementTransformation(elementId);
+
+            MFEM_VERIFY(
+                transformation != nullptr,
+                "PreparedBarotropicClosureOperator received "
+                "a null element transformation."
+            );
+
+            if (transformation->Attribute == vacuumAttribute) {
+                continue;
+            }
+
+            m_elements.emplace_back();
+            ElementPAData &data = m_elements.back();
+
+            data.densityDofTransformation =
+                m_fem.densityFes->GetElementDofs(elementId, data.densityDofs);
+
+            data.enthalpyDofTransformation =
+                m_fem.enthalpyFes->GetElementDofs(elementId, data.enthalpyDofs);
+
+            mfem::DofTransformation *displacementDofTransformation =
+                m_fem.displacementFes->GetElementVDofs(
+                    elementId, displacementDofs
+                );
+
+            mfem::DofTransformation *compactificationDofTransformation =
+                m_fem.compactificationFes->GetElementDofs(
+                    elementId, compactificationDofs
+                );
+
+            baseDensityLocal.GetSubVector(data.densityDofs, elementBaseDensity);
+
+            baseEnthalpyLocal.GetSubVector(
+                data.enthalpyDofs, elementBaseEnthalpy
+            );
+
+            displacementLocal.GetSubVector(
+                displacementDofs, elementDisplacement
+            );
+
+            m_fem.compactificationCoordinate->GetSubVector(
+                compactificationDofs, elementCompactification
+            );
+
+            if (data.densityDofTransformation != nullptr) {
+                data.densityDofTransformation->InvTransformPrimal(
+                    elementBaseDensity
+                );
+            }
+
+            if (data.enthalpyDofTransformation != nullptr) {
+                data.enthalpyDofTransformation->InvTransformPrimal(
+                    elementBaseEnthalpy
+                );
+            }
+
+            if (displacementDofTransformation != nullptr) {
+                displacementDofTransformation->InvTransformPrimal(
+                    elementDisplacement
+                );
+            }
+
+            if (compactificationDofTransformation != nullptr) {
+                compactificationDofTransformation->InvTransformPrimal(
+                    elementCompactification
+                );
+            }
+
+            const mfem::FiniteElement &densityElement =
+                *m_fem.densityFes->GetFE(elementId);
+
+            const mfem::FiniteElement &enthalpyElement =
+                *m_fem.enthalpyFes->GetFE(elementId);
+
+            const mfem::FiniteElement &displacementElement =
+                *m_fem.displacementFes->GetFE(elementId);
+
+            const mfem::FiniteElement &compactificationElement =
+                *m_fem.compactificationFes->GetFE(elementId);
+
+            const mapping::ElementDisplacementData displacementData =
+                mapping::ElementDisplacementDataFromElementVDofs(
+                    displacementElement, elementDisplacement
+                );
+
+            const mapping::ElementCompactificationData compactificationData(
+                compactificationElement, elementCompactification
+            );
+
+            const mapping::ElementMappingData mappingData{
+                .displacement     = displacementData,
+                .compactification = compactificationData
+            };
+
+            const mfem::IntegrationRule &integrationRule = get_eos_rule(
+                m_fem, m_barotrope, densityElement, enthalpyElement,
+                *transformation
+            );
+
+            const int quadraturePointCount = integrationRule.GetNPoints();
+
+            const int densityDofCount      = densityElement.GetDof();
+
+            const int enthalpyDofCount     = enthalpyElement.GetDof();
+
+            data.densityBasis.SetSize(quadraturePointCount, densityDofCount);
+
+            data.enthalpyBasis.SetSize(quadraturePointCount, enthalpyDofCount);
+
+            data.weightedResidual.SetSize(quadraturePointCount);
+
+            data.quadratureWeights.SetSize(quadraturePointCount);
+
+            data.weightedEnthalpyDerivative.SetSize(quadraturePointCount);
+
+            densityShape.SetSize(densityDofCount);
+
+            enthalpyShape.SetSize(enthalpyDofCount);
+
+            for (int quadraturePoint = 0;
+                 quadraturePoint < quadraturePointCount; ++quadraturePoint) {
+                const mfem::IntegrationPoint &integrationPoint =
+                    integrationRule.IntPoint(quadraturePoint);
+
+                transformation->SetIntPoint(&integrationPoint);
+
+                mapping::VolumeMappingContext mappingContext;
+
+                const mapping::MappingStatus mappingStatus =
+                    m_domainMapper.EvaluateVolume(
+                        mappingData, *transformation, integrationPoint,
+                        workspace, mappingContext
+                    );
+
+                MFEM_VERIFY(
+                    mappingStatus == mapping::MappingStatus::valid,
+                    "Stateless mapping failed while preparing "
+                    "the barotropic closure operator. Element: "
+                        << elementId
+                        << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadraturePoint
+                        << ", status: " << static_cast<int>(mappingStatus)
+                );
+
+                densityElement.CalcShape(integrationPoint, densityShape);
+
+                enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
+
+                for (int densityDof = 0; densityDof < densityDofCount;
+                     ++densityDof) {
+                    data.densityBasis(quadraturePoint, densityDof) =
+                        densityShape(densityDof);
+                }
+
+                for (int enthalpyDof = 0; enthalpyDof < enthalpyDofCount;
+                     ++enthalpyDof) {
+                    data.enthalpyBasis(quadraturePoint, enthalpyDof) =
+                        enthalpyShape(enthalpyDof);
+                }
+
+                const double density  = elementBaseDensity * densityShape;
+
+                const double enthalpy = elementBaseEnthalpy * enthalpyShape;
+
+                const double quadratureWeight =
+                    mappingContext.quadrature.weight;
+
+                const double eosDensity =
+                    m_barotrope.density_from_enthalpy(enthalpy);
+
+                const double enthalpyDerivative =
+                    m_barotrope.density_derivative_from_enthalpy(enthalpy);
+
+                MFEM_VERIFY(
+                    std::isfinite(quadratureWeight) && quadratureWeight > 0.0 &&
+                        std::isfinite(eosDensity) &&
+                        std::isfinite(enthalpyDerivative),
+                    "PreparedBarotropicClosureOperator "
+                    "encountered invalid quadrature data."
+                );
+
+                data.quadratureWeights(quadraturePoint) = quadratureWeight;
+
+                data.weightedResidual(quadraturePoint) =
+                    quadratureWeight * (density - eosDensity);
+
+                data.weightedEnthalpyDerivative(quadraturePoint) =
+                    quadratureWeight * enthalpyDerivative;
+            }
+        }
+
+        MFEM_VERIFY(
+            !m_elements.empty(), "PreparedBarotropicClosureOperator found no "
+                                 "stellar elements."
+        );
+
+        m_baseDensityTrue      = baseDensityTrue;
+        m_baseEnthalpyTrue     = baseEnthalpyTrue;
+        m_baseDisplacementTrue = displacementTrue;
+
+        m_isPrepared           = true;
+        ++m_preparationCount;
+    }
+
+    void PreparedBarotropicClosureOperator::BuildResidual(
+        mfem::Vector &residual
+    ) const {
+        MFEM_VERIFY(
+            m_isPrepared, "PreparedBarotropicClosureOperator must be "
+                          "prepared before BuildResidual is called."
+        );
+
+        mfem::Vector localResidual(m_fem.densityFes->GetVSize());
+        localResidual = 0.0;
+
+        mfem::Vector elementResidual;
+
+        for (const ElementPAData &data : m_elements) {
+            elementResidual.SetSize(data.densityDofs.Size());
+
+            data.densityBasis.MultTranspose(
+                data.weightedResidual, elementResidual
+            );
+
+            if (data.densityDofTransformation != nullptr) {
+                data.densityDofTransformation->TransformDual(elementResidual);
+            }
+
+            localResidual.AddElementVector(data.densityDofs, elementResidual);
+        }
+
+        local_to_true(*m_fem.densityFes, localResidual, residual);
+    }
+
+    void PreparedBarotropicClosureOperator::Mult(
+        const mfem::Vector &densityVariationTrue,
+        const mfem::Vector &enthalpyVariationTrue,
+        const mfem::Vector &displacementVariationTrue,
+        mfem::Vector &action
+    ) const {
+        VerifyPrepared();
+
+        MFEM_VERIFY(
+            densityVariationTrue.Size() == m_densitySize,
+            "The density-variation true vector has "
+            "the wrong size."
+        );
+
+        MFEM_VERIFY(
+            enthalpyVariationTrue.Size() == m_enthalpySize,
+            "The enthalpy-variation true vector has "
+            "the wrong size."
+        );
+
+        MFEM_VERIFY(
+            displacementVariationTrue.Size() ==
+                m_fem.displacementFes->GetTrueVSize(),
+            "The displacement-variation true vector has "
+            "the wrong size."
+        );
+
+        Mult(densityVariationTrue, enthalpyVariationTrue, action);
+
+        mfem::Vector displacementAction;
+
+        kernels::apply_barotropic_closure_displacement_action(
+            m_fem, m_domainMapper, m_barotrope, m_baseDensityTrue,
+            m_baseEnthalpyTrue, m_baseDisplacementTrue,
+            displacementVariationTrue, displacementAction
+        );
+
+        MFEM_VERIFY(
+            displacementAction.Size() == m_densitySize,
+            "The barotropic-closure displacement action "
+            "returned a vector with the wrong size."
+        );
+
+        action += displacementAction;
+    }
+
+    void PreparedBarotropicClosureOperator::Mult(
+        const mfem::Vector &combinedVariation,
+        mfem::Vector &action
+    ) const {
+        VerifyPrepared();
+
+        const int displacementSize = m_fem.displacementFes->GetTrueVSize();
+
+        const int combinedSize =
+            m_densitySize + m_enthalpySize + displacementSize;
+
+        MFEM_VERIFY(
+            combinedVariation.Size() == combinedSize,
+            "The combined barotropic-closure variation "
+            "vector has the wrong size. Expected "
+                << combinedSize << " entries but received "
+                << combinedVariation.Size() << "."
+        );
+
+        mfem::real_t *combinedData =
+            const_cast<mfem::real_t *>(combinedVariation.HostRead());
+
+        const mfem::Vector densityVariationTrue(combinedData, m_densitySize);
+
+        const mfem::Vector enthalpyVariationTrue(
+            combinedData + m_densitySize, m_enthalpySize
+        );
+
+        const mfem::Vector displacementVariationTrue(
+            combinedData + m_densitySize + m_enthalpySize, displacementSize
+        );
+
+        Mult(
+            densityVariationTrue, enthalpyVariationTrue,
+            displacementVariationTrue, action
+        );
+    }
+
+    void PreparedBarotropicClosureOperator::Mult(
+        const mfem::Vector &densityVariationTrue,
+        const mfem::Vector &enthalpyVariationTrue,
+        mfem::Vector &action
+    ) const {
+        MFEM_VERIFY(
+            m_isPrepared, "PreparedBarotropicClosureOperator must be "
+                          "prepared before Mult is called."
+        );
+
+        MFEM_VERIFY(
+            densityVariationTrue.Size() == m_densitySize,
+            "PreparedBarotropicClosureOperator received a "
+            "density variation with the wrong size."
+        );
+
+        MFEM_VERIFY(
+            enthalpyVariationTrue.Size() == m_enthalpySize,
+            "PreparedBarotropicClosureOperator received an "
+            "enthalpy variation with the wrong size."
+        );
+
+        mfem::Vector densityVariationLocal;
+        mfem::Vector enthalpyVariationLocal;
+
+        true_to_local(
+            *m_fem.densityFes, densityVariationTrue, densityVariationLocal
+        );
+
+        true_to_local(
+            *m_fem.enthalpyFes, enthalpyVariationTrue, enthalpyVariationLocal
+        );
+
+        mfem::Vector localAction(m_fem.densityFes->GetVSize());
+        localAction = 0.0;
+
+        mfem::Vector elementDensityVariation;
+        mfem::Vector elementEnthalpyVariation;
+        mfem::Vector quadratureDensityVariation;
+        mfem::Vector quadratureEnthalpyVariation;
+        mfem::Vector quadratureAction;
+        mfem::Vector elementAction;
+
+        for (const ElementPAData &data : m_elements) {
+            densityVariationLocal.GetSubVector(
+                data.densityDofs, elementDensityVariation
+            );
+
+            enthalpyVariationLocal.GetSubVector(
+                data.enthalpyDofs, elementEnthalpyVariation
+            );
+
+            if (data.densityDofTransformation != nullptr) {
+                data.densityDofTransformation->InvTransformPrimal(
+                    elementDensityVariation
+                );
+            }
+
+            if (data.enthalpyDofTransformation != nullptr) {
+                data.enthalpyDofTransformation->InvTransformPrimal(
+                    elementEnthalpyVariation
+                );
+            }
+
+            quadratureDensityVariation.SetSize(data.quadratureWeights.Size());
+
+            quadratureEnthalpyVariation.SetSize(data.quadratureWeights.Size());
+
+            quadratureAction.SetSize(data.quadratureWeights.Size());
+
+            data.densityBasis.Mult(
+                elementDensityVariation, quadratureDensityVariation
+            );
+
+            data.enthalpyBasis.Mult(
+                elementEnthalpyVariation, quadratureEnthalpyVariation
+            );
+
+            for (int quadraturePoint = 0;
+                 quadraturePoint < quadratureAction.Size(); ++quadraturePoint) {
+                quadratureAction(quadraturePoint) =
+                    data.quadratureWeights(quadraturePoint) *
+                        quadratureDensityVariation(quadraturePoint) -
+                    data.weightedEnthalpyDerivative(quadraturePoint) *
+                        quadratureEnthalpyVariation(quadraturePoint);
+            }
+
+            elementAction.SetSize(data.densityDofs.Size());
+
+            data.densityBasis.MultTranspose(quadratureAction, elementAction);
+
+            if (data.densityDofTransformation != nullptr) {
+                data.densityDofTransformation->TransformDual(elementAction);
+            }
+
+            localAction.AddElementVector(data.densityDofs, elementAction);
+        }
+
+        local_to_true(*m_fem.densityFes, localAction, action);
+    }
+
+    bool PreparedBarotropicClosureOperator::IsPrepared() const noexcept {
+        return m_isPrepared;
+    }
+
+    std::uint64_t
+    PreparedBarotropicClosureOperator::GetPreparationCount() const noexcept {
+        return m_preparationCount;
+    }
+
+    int PreparedBarotropicClosureOperator::GetDensitySize() const noexcept {
+        return m_densitySize;
+    }
+
+    int PreparedBarotropicClosureOperator::GetEnthalpySize() const noexcept {
+        return m_enthalpySize;
+    }
+
+    void PreparedBarotropicClosureOperator::VerifyPrepared() const {
+        MFEM_VERIFY(
+            m_isPrepared, "PreparedBarotropicClosureOperator must be "
+                          "prepared before this operation is called."
+        );
+    }
+} // namespace mean_field::operators

libmeanfield/impl/operators/prepared_gravity_source.cpp

@@ -0,0 +1,617 @@
+module;
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <mfem.hpp>
+#include <numbers>
+
+module mean_field;
+import :operators.prepared_gravity_source;
+
+namespace {
+    int get_operator_height(const mean_field::fem::FEM &f) {
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires the "
+            "gravity-potential "
+            "finite-element space."
+        );
+        return f.gravityPotentialFes->GetTrueVSize();
+    }
+
+    int get_operator_width(const mean_field::fem::FEM &f) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires the density "
+            "finite-element space."
+        );
+        return f.densityFes->GetTrueVSize();
+    }
+
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finite_element_space,
+        const mfem::Vector &true_vector,
+        mfem::Vector &local_vector
+    ) {
+        local_vector.SetSize(finite_element_space.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finite_element_space.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(true_vector, local_vector);
+        } else {
+            local_vector = true_vector;
+        }
+    }
+
+    void local_to_true(
+        const mfem::ParFiniteElementSpace &finite_element_space,
+        const mfem::Vector &local_vector,
+        mfem::Vector &true_vector
+    ) {
+        MFEM_VERIFY(
+            local_vector.Size() == finite_element_space.GetVSize(),
+            "Local vector has the wrong size."
+        );
+
+        true_vector.SetSize(finite_element_space.GetTrueVSize());
+        true_vector = 0.0;
+
+        const mfem::Operator *prolongation =
+            finite_element_space.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->MultTranspose(local_vector, true_vector);
+        } else {
+            true_vector = local_vector;
+        }
+    }
+
+    const mfem::IntegrationRule &get_source_rule(
+        const mean_field::fem::FEM &f,
+        const mfem::FiniteElement &density_element,
+        const mfem::FiniteElement &potential_element,
+        const mfem::ElementTransformation &transformation
+    ) {
+        using GravityField =
+            mean_field::field::Field<mean_field::field::Gravity>;
+        MFEM_VERIFY(
+            density_element.GetOrder() ==
+                mean_field::field::Density::Scalar::familyOrder,
+            "The prepared source trial element does not match the registered "
+            "density field."
+        );
+        MFEM_VERIFY(
+            potential_element.GetOrder() ==
+                mean_field::field::Gravity::Potential::familyOrder,
+            "The prepared source test element does not match the registered "
+            "gravity potential."
+        );
+        const mean_field::quadrature::Query query = GravityField::make_query<
+            mean_field::field::Gravity::Form::SourceProjection>(
+            mean_field::quadrature::QuadratureRole::discretization,
+            transformation.OrderW(), {}, mean_field::utils::DOMAINS::STELLAR,
+            mean_field::quadrature::MappingKind::general
+        );
+
+        return *f.quadratureFactory
+                    ->get(query, transformation.GetGeometryType())
+                    .integration_rule;
+    }
+
+    class FrozenMappedGravitySourceCoefficient final
+        : public mfem::Coefficient {
+    public:
+        FrozenMappedGravitySourceCoefficient(
+            const mean_field::fem::FEM &f,
+            const mean_field::mapping::DomainMapperStateless &domain_mapper,
+            const mfem::Vector &displacement_true
+        )
+            : m_fem(f),
+              m_domain_mapper(domain_mapper),
+              m_workspace(domain_mapper.GetDimension()) {
+            true_to_local(
+                *m_fem.displacementFes, displacement_true, m_displacement_local
+            );
+        }
+
+        double Eval(
+            mfem::ElementTransformation &transformation,
+            const mfem::IntegrationPoint &integration_point
+        ) override {
+            transformation.SetIntPoint(&integration_point);
+
+            const int element_id = transformation.ElementNo;
+            MFEM_VERIFY(
+                element_id >= 0 && element_id < m_fem.mesh->GetNE(),
+                "Mapped gravity source coefficient received an invalid element "
+                "ID."
+            );
+            if (transformation.Attribute ==
+                m_domain_mapper.GetVacuumElementAttribute()) {
+                return 0.0;
+            }
+
+            LoadElement(element_id);
+            const mean_field::mapping::ElementMappingData mapping_data{
+                .displacement     = *m_displacement_data,
+                .compactification = *m_compactification_data
+            };
+
+            mean_field::mapping::VolumeMappingContext mapping_context;
+
+            const mean_field::mapping::MappingStatus status =
+                m_domain_mapper.EvaluateVolume(
+                    mapping_data, transformation, integration_point,
+                    m_workspace, mapping_context
+                );
+
+            if (status != mean_field::mapping::MappingStatus::valid) {
+                const mfem::FiniteElement &displacement_element =
+                    *m_fem.displacementFes->GetFE(element_id);
+                const mfem::FiniteElement &compactification_element =
+                    *m_fem.compactificationFes->GetFE(element_id);
+
+                mfem::Vector displacement_shape(displacement_element.GetDof());
+                mfem::Vector compactification_shape(
+                    compactification_element.GetDof()
+                );
+                mfem::Vector reference_position(m_domain_mapper.GetDimension());
+                mfem::Vector displacement_value(m_domain_mapper.GetDimension());
+
+                displacement_element.CalcShape(
+                    integration_point, displacement_shape
+                );
+                compactification_element.CalcShape(
+                    integration_point, compactification_shape
+                );
+                transformation.Transform(integration_point, reference_position);
+                m_displacement_data->GetDofMatrix().MultTranspose(
+                    displacement_shape, displacement_value
+                );
+
+                const double compactification_coordinate =
+                    m_compactification_data->GetDofs() * compactification_shape;
+
+                MFEM_ABORT(
+                    "Stateless domain mapping failed while preparing the "
+                    "gravity "
+                    "source operator."
+                    << "\nMapping status = " << static_cast<int>(status)
+                    << "\nElement ID = " << element_id
+                    << "\nElement attribute = " << transformation.Attribute
+                    << "\nIntegration-point index = " << integration_point.index
+                    << "\nIntegration point = <" << integration_point.x << ", "
+                    << integration_point.y << ", " << integration_point.z << ">"
+                    << "\nReference position = <" << reference_position(0)
+                    << ", " << reference_position(1) << ", "
+                    << reference_position(2) << ">"
+                    << "\nReference radius = " << reference_position.Norml2()
+                    << "\nDisplacement value = <" << displacement_value(0)
+                    << ", " << displacement_value(1) << ", "
+                    << displacement_value(2) << ">"
+                    << "\nDisplacement magnitude = "
+                    << displacement_value.Norml2()
+                    << "\nCompactification coordinate = "
+                    << compactification_coordinate
+                    << "\nDisplacement ordering = "
+                    << static_cast<int>(m_fem.displacementFes->GetOrdering())
+                );
+            }
+            const double mapping_determinant =
+                mapping_context.mapping.mapping_determinant;
+            MFEM_VERIFY(
+                std::isfinite(mapping_determinant) && mapping_determinant > 0.0,
+                "Prepared gravity source operator encountered a non-positive "
+                "or "
+                "non-finite mapping determinant."
+            );
+
+            return 4.0 * std::numbers::pi * mean_field::utils::G *
+                   mapping_determinant;
+        }
+
+    private:
+        void LoadElement(const int element_id) {
+            if (element_id == m_cached_element_id) {
+                return;
+            }
+
+            const mfem::FiniteElement &displacement_element =
+                *m_fem.displacementFes->GetFE(element_id);
+            const mfem::FiniteElement &compactification_element =
+                *m_fem.compactificationFes->GetFE(element_id);
+
+            mfem::DofTransformation *displacement_dof_transformation =
+                m_fem.displacementFes->GetElementVDofs(
+                    element_id, m_displacement_dofs
+                );
+            mfem::DofTransformation *compactification_dof_transformation =
+                m_fem.compactificationFes->GetElementDofs(
+                    element_id, m_compactification_dofs
+                );
+
+            m_displacement_local.GetSubVector(
+                m_displacement_dofs, m_element_displacement
+            );
+            m_fem.compactificationCoordinate->GetSubVector(
+                m_compactification_dofs, m_element_compactification
+            );
+
+            if (displacement_dof_transformation != nullptr) {
+                displacement_dof_transformation->InvTransformPrimal(
+                    m_element_displacement
+                );
+            }
+
+            if (compactification_dof_transformation != nullptr) {
+                compactification_dof_transformation->InvTransformPrimal(
+                    m_element_compactification
+                );
+            }
+
+            m_displacement_data = std::make_unique<
+                mean_field::mapping::ElementDisplacementData>(
+                mean_field::mapping::ElementDisplacementDataFromElementVDofs(
+                    displacement_element, m_element_displacement
+                )
+            );
+
+            m_compactification_data = std::make_unique<
+                mean_field::mapping::ElementCompactificationData>(
+                compactification_element, m_element_compactification
+            );
+
+            m_cached_element_id = element_id;
+        }
+
+        const mean_field::fem::FEM &m_fem;
+        const mean_field::mapping::DomainMapperStateless &m_domain_mapper;
+
+        mfem::Vector m_displacement_local;
+
+        mfem::Array<int> m_displacement_dofs;
+        mfem::Array<int> m_compactification_dofs;
+
+        mfem::Vector m_element_displacement;
+        mfem::Vector m_element_compactification;
+
+        std::unique_ptr<mean_field::mapping::ElementDisplacementData>
+            m_displacement_data;
+        std::unique_ptr<mean_field::mapping::ElementCompactificationData>
+            m_compactification_data;
+
+        mean_field::mapping::DomainMapperStateless::Workspace m_workspace;
+        int m_cached_element_id{-1};
+    };
+} // namespace
+
+namespace mean_field::operators {
+    PreparedMappedGravitySourceOperator::PreparedMappedGravitySourceOperator(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper
+    )
+        : Operator(
+              get_operator_height(f),
+              get_operator_width(f)
+          ),
+          m_fem(f),
+          m_domain_mapper(domain_mapper) {
+        MFEM_VERIFY(
+            f.mesh != nullptr,
+            "PreparedMappedGravitySourceOperator requires a mesh."
+        );
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires the density "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires the "
+            "gravity-potential "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires "
+            "the displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "PreparedMappedGravitySourceOperator requires the compactification "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "PreparedMappedGravitySourceOperator requires the compactification "
+            "coordinate."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "PreparedMappedGravitySourceOperator "
+            "requires the quadrature-rule factory."
+        );
+        MFEM_VERIFY(
+            domain_mapper.GetDimension() == f.mesh->Dimension(),
+            "The stateless domain-mapper dimension does not match the mesh "
+            "dimension."
+        );
+
+        utils::populate_element_mask(
+            f.mesh.get(), utils::DOMAINS::STELLAR, m_stellar_marker
+        );
+    }
+
+    void PreparedMappedGravitySourceOperator::Prepare(
+        const mfem::Vector &displacement_true
+    ) {
+        MFEM_VERIFY(
+            displacement_true.Size() == m_fem.displacementFes->GetTrueVSize(),
+            "PreparedMappedGravitySourceOperator received a displacement "
+            "vector "
+            "with the wrong size."
+        );
+
+        for (int i = 0; i < displacement_true.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(displacement_true(i)),
+                "PreparedMappedGravitySourceOperator received a non-finite "
+                "displacement value."
+            );
+        }
+
+        m_is_prepared = false;
+        m_elements.clear();
+        m_elements.reserve(m_fem.mesh->GetNE());
+
+        FrozenMappedGravitySourceCoefficient source_coefficient(
+            m_fem, m_domain_mapper, displacement_true
+        );
+
+        for (int element_id = 0; element_id < m_fem.mesh->GetNE();
+             ++element_id) {
+            const int attribute = m_fem.mesh->GetAttribute(element_id);
+
+            if (attribute <= 0 || attribute > m_stellar_marker.Size() ||
+                m_stellar_marker[attribute - 1] == 0) {
+                continue;
+            }
+
+            m_elements.emplace_back();
+            ElementPAData &data = m_elements.back();
+
+            data.element_id     = element_id;
+
+            data.density_dof_transformation =
+                m_fem.densityFes->GetElementDofs(element_id, data.density_dofs);
+
+            data.potential_dof_transformation =
+                m_fem.gravityPotentialFes->GetElementDofs(
+                    element_id, data.potential_dofs
+                );
+
+            const mfem::FiniteElement &density_element =
+                *m_fem.densityFes->GetFE(element_id);
+
+            const mfem::FiniteElement &potential_element =
+                *m_fem.gravityPotentialFes->GetFE(element_id);
+
+            mfem::ElementTransformation &transformation =
+                *m_fem.mesh->GetElementTransformation(element_id);
+
+            const mfem::IntegrationRule &integration_rule = get_source_rule(
+                m_fem, density_element, potential_element, transformation
+            );
+
+            const int quadrature_point_count = integration_rule.GetNPoints();
+
+            const int density_dof_count      = density_element.GetDof();
+
+            const int potential_dof_count    = potential_element.GetDof();
+
+            data.density_basis.SetSize(
+                quadrature_point_count, density_dof_count
+            );
+
+            data.potential_basis.SetSize(
+                quadrature_point_count, potential_dof_count
+            );
+
+            data.quadrature_data.SetSize(quadrature_point_count);
+
+            mfem::Vector density_shape(density_dof_count);
+            mfem::Vector potential_shape(potential_dof_count);
+
+            for (int quadrature_point = 0;
+                 quadrature_point < quadrature_point_count;
+                 ++quadrature_point) {
+                const mfem::IntegrationPoint &integration_point =
+                    integration_rule.IntPoint(quadrature_point);
+
+                transformation.SetIntPoint(&integration_point);
+
+                // CalcPhysShape matches the scalar mixed-mass discretization,
+                // including the finite-element map type.
+                density_element.CalcPhysShape(transformation, density_shape);
+
+                potential_element.CalcPhysShape(
+                    transformation, potential_shape
+                );
+
+                for (int i = 0; i < density_dof_count; ++i) {
+                    data.density_basis(quadrature_point, i) = density_shape(i);
+                }
+
+                for (int i = 0; i < potential_dof_count; ++i) {
+                    data.potential_basis(quadrature_point, i) =
+                        potential_shape(i);
+                }
+
+                const double coefficient_value =
+                    source_coefficient.Eval(transformation, integration_point);
+
+                transformation.SetIntPoint(&integration_point);
+
+                const double quadrature_value = integration_point.weight *
+                                                transformation.Weight() *
+                                                coefficient_value;
+
+                MFEM_VERIFY(
+                    std::isfinite(quadrature_value) && quadrature_value > 0.0,
+                    "Prepared gravity source operator encountered invalid "
+                    "quadrature data on element "
+                        << element_id << ", quadrature point "
+                        << quadrature_point << "."
+                );
+
+                data.quadrature_data(quadrature_point) = quadrature_value;
+            }
+        }
+
+        MFEM_VERIFY(
+            !m_elements.empty(),
+            "PreparedMappedGravitySourceOperator found no stellar elements."
+        );
+
+        m_is_prepared = true;
+        ++m_preparation_count;
+    }
+    void PreparedMappedGravitySourceOperator::Mult(
+        const mfem::Vector &density_true,
+        mfem::Vector &action
+    ) const {
+        MFEM_VERIFY(
+            m_is_prepared,
+            "PreparedMappedGravitySourceOperator must be prepared before "
+            "Mult is called."
+        );
+
+        MFEM_VERIFY(
+            density_true.Size() == Width(),
+            "PreparedMappedGravitySourceOperator received a density vector "
+            "with the wrong size."
+        );
+
+        mfem::Vector density_local;
+
+        true_to_local(*m_fem.densityFes, density_true, density_local);
+
+        mfem::Vector local_action(m_fem.gravityPotentialFes->GetVSize());
+        local_action = 0.0;
+
+        mfem::Vector element_density;
+        mfem::Vector quadrature_density;
+        mfem::Vector element_action;
+
+        for (const ElementPAData &data : m_elements) {
+            density_local.GetSubVector(data.density_dofs, element_density);
+
+            if (data.density_dof_transformation != nullptr) {
+                data.density_dof_transformation->InvTransformPrimal(
+                    element_density
+                );
+            }
+
+            quadrature_density.SetSize(data.quadrature_data.Size());
+
+            // B_density * x_e
+            data.density_basis.Mult(element_density, quadrature_density);
+
+            // D * B_density * x_e
+            for (int q = 0; q < quadrature_density.Size(); ++q) {
+                quadrature_density(q) *= data.quadrature_data(q);
+            }
+
+            element_action.SetSize(data.potential_dofs.Size());
+
+            // B_potential^T * D * B_density * x_e
+            data.potential_basis.MultTranspose(
+                quadrature_density, element_action
+            );
+
+            if (data.potential_dof_transformation != nullptr) {
+                data.potential_dof_transformation->TransformDual(
+                    element_action
+                );
+            }
+
+            local_action.AddElementVector(data.potential_dofs, element_action);
+        }
+
+        local_to_true(*m_fem.gravityPotentialFes, local_action, action);
+    }
+
+    void PreparedMappedGravitySourceOperator::MultTranspose(
+        const mfem::Vector &potential_true,
+        mfem::Vector &action
+    ) const {
+        MFEM_VERIFY(
+            m_is_prepared,
+            "PreparedMappedGravitySourceOperator must be prepared before "
+            "MultTranspose is called."
+        );
+
+        MFEM_VERIFY(
+            potential_true.Size() == Height(),
+            "PreparedMappedGravitySourceOperator received a potential vector "
+            "with the wrong size."
+        );
+
+        mfem::Vector potential_local;
+
+        true_to_local(
+            *m_fem.gravityPotentialFes, potential_true, potential_local
+        );
+
+        mfem::Vector local_action(m_fem.densityFes->GetVSize());
+        local_action = 0.0;
+
+        mfem::Vector element_potential;
+        mfem::Vector quadrature_potential;
+        mfem::Vector element_action;
+
+        for (const ElementPAData &data : m_elements) {
+            potential_local.GetSubVector(
+                data.potential_dofs, element_potential
+            );
+
+            if (data.potential_dof_transformation != nullptr) {
+                data.potential_dof_transformation->InvTransformPrimal(
+                    element_potential
+                );
+            }
+
+            quadrature_potential.SetSize(data.quadrature_data.Size());
+
+            data.potential_basis.Mult(element_potential, quadrature_potential);
+
+            for (int q = 0; q < quadrature_potential.Size(); ++q) {
+                quadrature_potential(q) *= data.quadrature_data(q);
+            }
+
+            element_action.SetSize(data.density_dofs.Size());
+
+            data.density_basis.MultTranspose(
+                quadrature_potential, element_action
+            );
+
+            if (data.density_dof_transformation != nullptr) {
+                data.density_dof_transformation->TransformDual(element_action);
+            }
+
+            local_action.AddElementVector(data.density_dofs, element_action);
+        }
+
+        local_to_true(*m_fem.densityFes, local_action, action);
+    }
+    bool PreparedMappedGravitySourceOperator::IsPrepared() const noexcept {
+        return m_is_prepared;
+    }
+
+    std::uint64_t
+    PreparedMappedGravitySourceOperator::GetPreparationCount() const noexcept {
+        return m_preparation_count;
+    }
+} // namespace mean_field::operators

libmeanfield/impl/operators/prepared_hdiv_mass.cpp

@@ -0,0 +1,441 @@
+module;
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <mfem.hpp>
+
+module mean_field;
+import :operators.prepared_hdiv_mass;
+
+namespace {
+    int get_operator_size(const mean_field::fem::FEM &f) {
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "PreparedMappedHDivMassOperator requires the "
+            "gravity-gradient finite-element space."
+        );
+        return f.gravityFluxFes->GetTrueVSize();
+    }
+
+    void true_to_local(
+        const mfem::ParFiniteElementSpace &finite_element_space,
+        const mfem::Vector &true_vector,
+        mfem::Vector &local_vector
+    ) {
+        local_vector.SetSize(finite_element_space.GetVSize());
+
+        const mfem::Operator *prolongation =
+            finite_element_space.GetProlongationMatrix();
+
+        if (prolongation != nullptr) {
+            prolongation->Mult(true_vector, local_vector);
+        } else {
+            local_vector = true_vector;
+        }
+    }
+
+    int find_representative_element(
+        const mean_field::fem::FEM &f,
+        const mfem::Array<int> &marker
+    ) {
+        for (int element_id = 0; element_id < f.mesh->GetNE(); ++element_id) {
+            const int attribute = f.mesh->GetAttribute(element_id);
+
+            if (attribute > 0 && attribute <= marker.Size() &&
+                marker[attribute - 1] != 0) {
+                return element_id;
+            }
+        }
+
+        return -1;
+    }
+
+    void validate_uniform_domain_discretization(
+        const mean_field::fem::FEM &f,
+        const mfem::Array<int> &marker,
+        const int representative_element_id
+    ) {
+        const mfem::FiniteElement &representative_element =
+            *f.gravityFluxFes->GetFE(representative_element_id);
+        const mfem::ElementTransformation &representative_transformation =
+            *f.mesh->GetElementTransformation(representative_element_id);
+
+        for (int element_id = 0; element_id < f.mesh->GetNE(); ++element_id) {
+            const int attribute = f.mesh->GetAttribute(element_id);
+
+            if (attribute <= 0 || attribute > marker.Size() ||
+                marker[attribute - 1] == 0) {
+                continue;
+            }
+
+            const mfem::FiniteElement &element =
+                *f.gravityFluxFes->GetFE(element_id);
+            const mfem::ElementTransformation &transformation =
+                *f.mesh->GetElementTransformation(element_id);
+
+            MFEM_VERIFY(
+                element.GetGeomType() == representative_element.GetGeomType(),
+                "Prepared H(div) mass domains currently require a uniform "
+                "element "
+                "geometry."
+            );
+            MFEM_VERIFY(
+                element.GetOrder() == representative_element.GetOrder(),
+                "Prepared H(div) mass domains currently require a uniform "
+                "finite-element order."
+            );
+            MFEM_VERIFY(
+                transformation.OrderW() ==
+                    representative_transformation.OrderW(),
+                "Prepared H(div) mass domains currently require a uniform "
+                "geometry-weight order."
+            );
+        }
+    }
+
+    class FrozenMappedHDivMassCoefficient final
+        : public mfem::MatrixCoefficient {
+    public:
+        FrozenMappedHDivMassCoefficient(
+            const mean_field::fem::FEM &f,
+            const mean_field::mapping::DomainMapperStateless &domain_mapper,
+            const mfem::Vector &displacement_true,
+            bool elevates_vacuum
+        )
+            : MatrixCoefficient(domain_mapper.GetDimension()),
+              m_fem(f),
+              m_domain_mapper(domain_mapper),
+              m_workspace(domain_mapper.GetDimension()),
+              m_elevates_vacuum(elevates_vacuum) {
+            true_to_local(
+                *m_fem.displacementFes, displacement_true, m_displacement_local
+            );
+        }
+
+        void Eval(
+            mfem::DenseMatrix &mass_tensor,
+            mfem::ElementTransformation &transformation,
+            const mfem::IntegrationPoint &integration_point
+        ) override {
+            transformation.SetIntPoint(&integration_point);
+
+            const int element_id = transformation.ElementNo;
+            MFEM_VERIFY(
+                element_id >= 0 && element_id < m_fem.mesh->GetNE(),
+                "Mapped H(div) mass coefficient received an invalid element ID."
+            );
+
+            const bool element_is_vacuum =
+                transformation.Attribute ==
+                m_domain_mapper.GetVacuumElementAttribute();
+
+            if (element_is_vacuum != m_elevates_vacuum) {
+                mass_tensor.SetSize(m_domain_mapper.GetDimension());
+                mass_tensor = 0.0;
+                return;
+            }
+
+            LoadElement(element_id);
+
+            const mean_field::mapping::ElementMappingData mapping_data{
+                .displacement     = *m_displacement_data,
+                .compactification = *m_compactification_data
+            };
+
+            mean_field::mapping::VolumeMappingContext mapping_context;
+
+            const mean_field::mapping::MappingStatus status =
+                m_domain_mapper.EvaluateVolume(
+                    mapping_data, transformation, integration_point,
+                    m_workspace, mapping_context
+                );
+
+            MFEM_VERIFY(
+                status == mean_field::mapping::MappingStatus::valid,
+                "Stateless domain mapping failed while preparing the H(div) "
+                "mass "
+                "operator. Mapping status = "
+                    << static_cast<int>(status)
+                    << ", element ID = " << element_id
+                    << ", element attribute = " << transformation.Attribute
+                    << ", coefficient domain = "
+                    << (m_elevates_vacuum ? "vacuum" : "stellar")
+            );
+
+            const mfem::DenseMatrix &mapping_jacobian =
+                mapping_context.mapping.mapping_jacobian;
+            const double mapping_determinant =
+                mapping_context.mapping.mapping_determinant;
+
+            MFEM_VERIFY(
+                std::isfinite(mapping_determinant) && mapping_determinant > 0.0,
+                "Prepared H(div) mass operator encountered a non-positive or "
+                "non-finite mapping determinant."
+            );
+
+            mfem::MultAtB(mapping_jacobian, mapping_jacobian, mass_tensor);
+            mass_tensor *= 1.0 / mapping_determinant;
+        }
+
+    private:
+        void LoadElement(const int element_id) {
+            if (element_id == m_cached_element_id) {
+                return;
+            }
+
+            const mfem::FiniteElement &displacement_element =
+                *m_fem.displacementFes->GetFE(element_id);
+            const mfem::FiniteElement &compactification_element =
+                *m_fem.compactificationFes->GetFE(element_id);
+
+            mfem::DofTransformation *displacement_dof_transformation =
+                m_fem.displacementFes->GetElementVDofs(
+                    element_id, m_displacement_dofs
+                );
+            mfem::DofTransformation *compactification_dof_transformation =
+                m_fem.compactificationFes->GetElementDofs(
+                    element_id, m_compactification_dofs
+                );
+
+            m_displacement_local.GetSubVector(
+                m_displacement_dofs, m_element_displacement
+            );
+            m_fem.compactificationCoordinate->GetSubVector(
+                m_compactification_dofs, m_element_compactification
+            );
+
+            if (displacement_dof_transformation != nullptr) {
+                displacement_dof_transformation->InvTransformPrimal(
+                    m_element_displacement
+                );
+            }
+
+            if (compactification_dof_transformation != nullptr) {
+                compactification_dof_transformation->InvTransformPrimal(
+                    m_element_compactification
+                );
+            }
+
+            m_displacement_data = std::make_unique<
+                mean_field::mapping::ElementDisplacementData>(
+                mean_field::mapping::ElementDisplacementDataFromElementVDofs(
+                    displacement_element, m_element_displacement
+                )
+            );
+
+            m_compactification_data = std::make_unique<
+                mean_field::mapping::ElementCompactificationData>(
+                compactification_element, m_element_compactification
+            );
+
+            m_cached_element_id = element_id;
+        }
+
+        const mean_field::fem::FEM &m_fem;
+        const mean_field::mapping::DomainMapperStateless &m_domain_mapper;
+
+        mfem::Vector m_displacement_local;
+
+        mfem::Array<int> m_displacement_dofs;
+        mfem::Array<int> m_compactification_dofs;
+
+        mfem::Vector m_element_displacement;
+        mfem::Vector m_element_compactification;
+
+        std::unique_ptr<mean_field::mapping::ElementDisplacementData>
+            m_displacement_data;
+        std::unique_ptr<mean_field::mapping::ElementCompactificationData>
+            m_compactification_data;
+
+        mean_field::mapping::DomainMapperStateless::Workspace m_workspace;
+        int m_cached_element_id{-1};
+        bool m_elevates_vacuum;
+    };
+} // namespace
+
+namespace mean_field::operators {
+    PreparedMappedHDivMassOperator::PreparedMappedHDivMassOperator(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domain_mapper
+    )
+        : Operator(get_operator_size(f)),
+          m_fem(f),
+          m_domain_mapper(domain_mapper) {
+        MFEM_VERIFY(
+            f.mesh != nullptr, "PreparedMappedHDivMassOperator requires a mesh."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "PreparedMappedHDivMassOperator requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr,
+            "PreparedMappedHDivMassOperator requires the "
+            "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationFes != nullptr,
+            "PreparedMappedHDivMassOperator requires the compactification "
+            "finite-element space."
+        );
+        MFEM_VERIFY(
+            f.compactificationCoordinate != nullptr,
+            "PreparedMappedHDivMassOperator requires the compactification "
+            "coordinate."
+        );
+        MFEM_VERIFY(
+            f.quadratureFactory != nullptr,
+            "PreparedMappedHDivMassOperator requires the quadrature-rule "
+            "factory."
+        );
+        MFEM_VERIFY(
+            domain_mapper.GetDimension() == f.mesh->Dimension(),
+            "The stateless domain-mapper dimension does not match the mesh "
+            "dimension."
+        );
+
+        utils::populate_element_mask(
+            f.mesh.get(), utils::DOMAINS::STELLAR, m_stellar_marker
+        );
+        utils::populate_element_mask(
+            f.mesh.get(), utils::DOMAINS::VACUUM, m_vacuum_marker
+        );
+
+        const int stellar_element_id =
+            find_representative_element(f, m_stellar_marker);
+        const int vacuum_element_id =
+            find_representative_element(f, m_vacuum_marker);
+
+        MFEM_VERIFY(
+            stellar_element_id >= 0, "PreparedMappedHDivMassOperator requires "
+                                     "at least one stellar element."
+        );
+        MFEM_VERIFY(
+            vacuum_element_id >= 0,
+            "PreparedMappedHDivMassOperator requires at "
+            "least one compactified vacuum element."
+        );
+
+        validate_uniform_domain_discretization(
+            f, m_stellar_marker, stellar_element_id
+        );
+        validate_uniform_domain_discretization(
+            f, m_vacuum_marker, vacuum_element_id
+        );
+    }
+
+    void PreparedMappedHDivMassOperator::Prepare(
+        const mfem::Vector &displacement_true
+    ) {
+        MFEM_VERIFY(
+            displacement_true.Size() == m_fem.displacementFes->GetTrueVSize(),
+            "PreparedMappedHDivMassOperator received a displacement vector "
+            "with "
+            "the wrong size."
+        );
+
+        for (int i = 0; i < displacement_true.Size(); ++i) {
+            MFEM_VERIFY(
+                std::isfinite(displacement_true(i)),
+                "PreparedMappedHDivMassOperator received a non-finite "
+                "displacement "
+                "value."
+            );
+        }
+
+        const int stellar_element_id =
+            find_representative_element(m_fem, m_stellar_marker);
+        const int vacuum_element_id =
+            find_representative_element(m_fem, m_vacuum_marker);
+
+        const mfem::FiniteElement &stellar_element =
+            *m_fem.gravityFluxFes->GetFE(stellar_element_id);
+        const mfem::FiniteElement &vacuum_element =
+            *m_fem.gravityFluxFes->GetFE(vacuum_element_id);
+
+        mfem::ElementTransformation &stellar_transformation =
+            *m_fem.mesh->GetElementTransformation(stellar_element_id);
+        mfem::ElementTransformation &vacuum_transformation =
+            *m_fem.mesh->GetElementTransformation(vacuum_element_id);
+
+        m_mass_form.reset();
+        m_stellar_mass_coefficient.reset();
+        m_vacuum_mass_coefficient.reset();
+
+        m_stellar_mass_coefficient =
+            std::make_unique<FrozenMappedHDivMassCoefficient>(
+                m_fem, m_domain_mapper, displacement_true, false
+            );
+        m_vacuum_mass_coefficient =
+            std::make_unique<FrozenMappedHDivMassCoefficient>(
+                m_fem, m_domain_mapper, displacement_true, true
+            );
+
+        m_mass_form =
+            std::make_unique<mfem::ParBilinearForm>(m_fem.gravityFluxFes.get());
+        m_mass_form->SetAssemblyLevel(mfem::AssemblyLevel::PARTIAL);
+
+        auto stellar_integrator =
+            std::make_unique<mfem::VectorFEMassIntegrator>(
+                *m_stellar_mass_coefficient
+            );
+        auto vacuum_integrator = std::make_unique<mfem::VectorFEMassIntegrator>(
+            *m_vacuum_mass_coefficient
+        );
+
+        m_fem.quadratureFactory->configure_gravity_hdiv_mass(
+            *stellar_integrator, quadrature::QuadratureRole::discretization,
+            stellar_element, stellar_transformation, utils::DOMAINS::STELLAR,
+            quadrature::MappingKind::general
+        );
+
+        m_fem.quadratureFactory->configure_gravity_hdiv_mass(
+            *vacuum_integrator, quadrature::QuadratureRole::discretization,
+            vacuum_element, vacuum_transformation, utils::DOMAINS::VACUUM,
+            quadrature::MappingKind::kelvin
+        );
+
+        m_mass_form->AddDomainIntegrator(
+            stellar_integrator.release(), m_stellar_marker
+        );
+        m_mass_form->AddDomainIntegrator(
+            vacuum_integrator.release(), m_vacuum_marker
+        );
+        m_mass_form->Assemble();
+
+        m_is_prepared = true;
+        ++m_preparation_count;
+    }
+
+    void PreparedMappedHDivMassOperator::Mult(
+        const mfem::Vector &gravity_gradient_true,
+        mfem::Vector &action
+    ) const {
+        MFEM_VERIFY(
+            m_is_prepared, "PreparedMappedHDivMassOperator must be prepared "
+                           "before Mult is called."
+        );
+        MFEM_VERIFY(
+            m_mass_form != nullptr, "PreparedMappedHDivMassOperator has no "
+                                    "assembled partial-assembly form."
+        );
+        MFEM_VERIFY(
+            gravity_gradient_true.Size() == Width(),
+            "PreparedMappedHDivMassOperator received a gravity-gradient vector "
+            "with the wrong size."
+        );
+
+        action.SetSize(Height());
+        m_mass_form->Mult(gravity_gradient_true, action);
+    }
+
+    bool PreparedMappedHDivMassOperator::IsPrepared() const noexcept {
+        return m_is_prepared;
+    }
+
+    std::uint64_t
+    PreparedMappedHDivMassOperator::GetPreparationCount() const noexcept {
+        return m_preparation_count;
+    }
+} // namespace mean_field::operators

libmeanfield/impl/physics/gravity.cpp

@@ -1,21 +1,55 @@
 module;
 #include "mfem.hpp"
-#include <source_location>
+#include <array>
 #include <cmath>
+#include <format>
+#include <source_location>
 #include <string_view>
 #include <unordered_map>
-#include <format>
 
 module mean_field;
 import :mapping.coefficients;
 import :analysis.integral;
 
 namespace {
-    double centrifugal_potential(const mfem::Vector &phys_x, const double omega) {
+    double centrifugal_potential(
+        const mfem::Vector &phys_x,
+        const double omega
+    ) {
         const double s2 = std::pow(phys_x(0), 2) + std::pow(phys_x(1), 2);
         return -0.5 * s2 * std::pow(omega, 2);
     }
-}
+
+    void grid_function_to_true_dofs(
+        const mfem::ParFiniteElementSpace &finite_element_space,
+        const mfem::GridFunction &grid_function,
+        mfem::Vector &true_dofs
+    ) {
+        MFEM_VERIFY(
+            grid_function.Size() == finite_element_space.GetVSize(),
+            "The grid function does not match the requested finite-element "
+            "space."
+        );
+
+        true_dofs.SetSize(finite_element_space.GetTrueVSize());
+
+        const mfem::Operator *restriction =
+            finite_element_space.GetRestrictionMatrix();
+
+        if (restriction != nullptr) {
+            restriction->Mult(grid_function, true_dofs);
+        } else {
+            MFEM_VERIFY(
+                grid_function.Size() == true_dofs.Size(),
+                "A finite-element space without a restriction operator must "
+                "have "
+                "matching local and true sizes."
+            );
+
+            true_dofs = grid_function;
+        }
+    }
+} // namespace
 
 namespace mean_field::physics {
     GravitySolution grav_potential(
@@ -24,68 +58,106 @@ namespace mean_field::physics {
         const mfem::GridFunction &rho,
         const bool phi_warm
     ) {
+        MFEM_VERIFY(
+            f.densityFes != nullptr && rho.FESpace() == f.densityFes.get(),
+            "Gravity solve requires rho to use the registered density space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "Gravity solve requires the registered gravity-potential space."
+        );
+
         mfem::Array<int> outer_bdr_marker(f.mesh->bdr_attributes.Max());
-        outer_bdr_marker = 0;
+        outer_bdr_marker    = 0;
         outer_bdr_marker[1] = 1;
 
-        mfem::ParLinearForm g_rhs(f.RT_fes.get());
+        mfem::ParLinearForm g_rhs(f.gravityFluxFes.get());
 
         // ReSharper disable once CppTooWideScope
         std::unique_ptr<mfem::Coefficient> boundary_potential_coeff;
 
-        if (!f.has_mapping()) { // We only need to explicitly add a boundary integrator if a mapping is not being used. In the case where the outer domain has been compactified the φ=0 boundary condition is the natural condition and MFEM automatically handles this
-            auto boundary_potential = [&f](const mfem::Vector& x_physical) {
+        if (!f.has_mapping()) { // We only need to explicitly add a boundary
+                                // integrator if a mapping is not being used. In
+                                // the case where the outer domain has been
+                                // compactified the φ=0 boundary condition is
+                                // the natural condition and MFEM automatically
+                                // handles this
+            auto boundary_potential = [&f](const mfem::Vector &x_physical) {
                 return l2_multipole_potential(f, utils::MASS, x_physical);
             };
 
-            boundary_potential_coeff = std::make_unique<mfem::FunctionCoefficient>(boundary_potential);
-            auto boundary_integrator = std::make_unique<mfem::VectorFEBoundaryFluxLFIntegrator>(*boundary_potential_coeff);
-            const mfem::FiniteElement& boundary_element = *f.RT_fes->GetTypicalTraceElement();
+            boundary_potential_coeff =
+                std::make_unique<mfem::FunctionCoefficient>(boundary_potential);
+            auto boundary_integrator =
+                std::make_unique<mfem::VectorFEBoundaryFluxLFIntegrator>(
+                    *boundary_potential_coeff
+                );
+            const mfem::FiniteElement &boundary_element =
+                *f.gravityFluxFes->GetTypicalTraceElement();
 
-            f.quadrature_factory->configure_gravity_boundary(*boundary_integrator, quadrature::QuadratureRole::discretization, boundary_element, utils::DOMAINS::VACUUM, quadrature::MappingKind::none);
-            g_rhs.AddBoundaryIntegrator(boundary_integrator.release(), outer_bdr_marker);
+            f.quadratureFactory->configure_gravity_boundary(
+                *boundary_integrator,
+                quadrature::QuadratureRole::discretization, boundary_element,
+                utils::DOMAINS::VACUUM, quadrature::MappingKind::none
+            );
+            g_rhs.AddBoundaryIntegrator(
+                boundary_integrator.release(), outer_bdr_marker
+            );
         }
 
         g_rhs.Assemble();
         mfem::GridFunctionCoefficient rho_coeff(&rho);
         mfem::ConstantCoefficient G4pi(4.0 * M_PI * utils::G);
         mfem::ProductCoefficient source_coeff(G4pi, rho_coeff);
-        mfem::ParLinearForm f_rhs(f.L2_fes.get());
+        mfem::ParLinearForm f_rhs(f.gravityPotentialFes.get());
 
         std::unique_ptr<mfem::Coefficient> mapped_source_coeff;
-        mfem::Coefficient* active_source_coeff = &source_coeff;
-        quadrature::MappingKind source_mapping_kind = quadrature::MappingKind::none;
+        mfem::Coefficient *active_source_coeff = &source_coeff;
+        quadrature::MappingKind source_mapping_kind =
+            quadrature::MappingKind::none;
 
         if (f.has_mapping()) {
-            mapped_source_coeff = std::make_unique<mapping::MappedScalarCoefficient>(*f.mapping, source_coeff);
+            mapped_source_coeff =
+                std::make_unique<mapping::MappedScalarCoefficient>(
+                    *f.mapping, source_coeff
+                );
             active_source_coeff = mapped_source_coeff.get();
             source_mapping_kind = quadrature::MappingKind::general;
         }
 
-        auto source_integrator = std::make_unique<mfem::DomainLFIntegrator>(*active_source_coeff);
-        const mfem::FiniteElement& source_test_element = *f.L2_fes->GetTypicalFE();
-        const mfem::ElementTransformation& source_transformation = *f.mesh->GetElementTransformation(0);
-        const int source_coefficient_order = f.L2_fes->GetMaxElementOrder();
+        auto source_integrator =
+            std::make_unique<mfem::DomainLFIntegrator>(*active_source_coeff);
+        const mfem::FiniteElement &source_test_element =
+            *f.gravityPotentialFes->GetTypicalFE();
+        const mfem::ElementTransformation &source_transformation =
+            *f.mesh->GetElementTransformation(0);
+        const int source_coefficient_order = f.densityFes->GetMaxElementOrder();
 
-        f.quadrature_factory->configure_gravity_source(*source_integrator, quadrature::QuadratureRole::discretization, source_test_element, source_transformation, source_coefficient_order, utils::DOMAINS::STELLAR, source_mapping_kind);
-        f_rhs.AddDomainIntegrator(source_integrator.release(), f.gravity_context.stellar_mask);
+        f.quadratureFactory->configure_gravity_source(
+            *source_integrator, quadrature::QuadratureRole::discretization,
+            source_test_element, source_transformation,
+            source_coefficient_order, utils::DOMAINS::STELLAR,
+            source_mapping_kind
+        );
+        f_rhs.AddDomainIntegrator(
+            source_integrator.release(), f.gravityContext.stellar_mask
+        );
         f_rhs.Assemble();
 
-        mfem::BlockVector RHS(f.gravity_block_true_offsets);
+        mfem::BlockVector RHS(f.gravityBlockTrueOffsets);
         RHS.GetBlock(0) = *g_rhs.ParallelAssemble();
         RHS.GetBlock(1) = *f_rhs.ParallelAssemble();
 
-        mfem::BlockVector X(f.gravity_block_true_offsets);
+        mfem::BlockVector X(f.gravityBlockTrueOffsets);
         X = 0.0;
-        f.gravity_context.minres->SetOperator(*f.gravity_context.block_A);
-        f.gravity_context.minres->Mult(RHS, X);
+        f.gravityContext.minres->SetOperator(*f.gravityContext.block_A);
+        f.gravityContext.minres->Mult(RHS, X);
 
         GravitySolution solution(f);
         solution.gradPhi.SetFromTrueDofs(X.GetBlock(0));
         solution.phi.SetFromTrueDofs(X.GetBlock(1));
 
         return solution;
-
     }
 
     mfem::GridFunction get_potential(
@@ -105,18 +177,21 @@ namespace mean_field::physics {
 
             std::unique_ptr<mfem::Coefficient> centrifugal_coeff;
             if (fem.has_mapping()) {
-                centrifugal_coeff = std::make_unique<mapping::PhysicalPositionFunctionCoefficient>(*fem.mapping, rot);
+                centrifugal_coeff = std::make_unique<
+                    mapping::PhysicalPositionFunctionCoefficient>(
+                    *fem.mapping, rot
+                );
             } else {
-                centrifugal_coeff = std::make_unique<mfem::FunctionCoefficient>(rot);
+                centrifugal_coeff =
+                    std::make_unique<mfem::FunctionCoefficient>(rot);
             }
 
-            mfem::GridFunction centrifugal_gf(fem.H1_fes.get());
+            mfem::GridFunction centrifugal_gf(fem.gravityPotentialFes.get());
             centrifugal_gf.ProjectCoefficient(*centrifugal_coeff);
 
             phi.phi += centrifugal_gf;
         }
         return phi.phi;
-
     }
 
     mfem::DenseMatrix compute_quadrupole_moment_tensor(
@@ -128,11 +203,23 @@ namespace mean_field::physics {
         mfem::DenseMatrix local_Q(dim, dim);
         local_Q = 0.0;
 
-        for (int i = 0; i < fem.H1_fes->GetNE(); ++i) {
-            if (fem.mesh->GetAttribute(i) == 3) continue;
+        for (int i = 0; i < fem.mesh->GetNE(); ++i) {
+            if (fem.mesh->GetAttribute(i) == 3)
+                continue;
 
-            mfem::ElementTransformation *trans = fem.mesh->GetElementTransformation(i);
-            const mfem::IntegrationRule &ir = *fem.int_rule;
+            mfem::ElementTransformation *trans =
+                fem.mesh->GetElementTransformation(i);
+            using DensityField = field::Field<field::Density>;
+            const quadrature::Query query =
+                DensityField::make_query<field::Density::Form::Quadrupole>(
+                    quadrature::QuadratureRole::diagnostic, trans->OrderW(),
+                    std::array<int, 1>{2}, utils::DOMAINS::STELLAR,
+                    fem.has_mapping() ? quadrature::MappingKind::general
+                                      : quadrature::MappingKind::none
+                );
+            const mfem::IntegrationRule &ir =
+                *fem.quadratureFactory->get(query, trans->GetGeometryType())
+                     .integration_rule;
 
             for (int j = 0; j < ir.GetNPoints(); ++j) {
                 const mfem::IntegrationPoint &ip = ir.IntPoint(j);
@@ -164,7 +251,8 @@ namespace mean_field::physics {
                 for (int m = 0; m < dim; ++m) {
                     for (int n = 0; n < dim; ++n) {
                         const double delta = (m == n) ? 1.0 : 0.0;
-                        const double contrib = 3.0 * x_prime(m) * x_prime(n) - delta * r_sq;
+                        const double contrib =
+                            3.0 * x_prime(m) * x_prime(n) - delta * r_sq;
                         local_Q(m, n) += rho_val * contrib * weight;
                     }
                 }
@@ -172,7 +260,10 @@ namespace mean_field::physics {
         }
 
         mfem::DenseMatrix global_Q(dim, dim);
-        MPI_Allreduce(local_Q.GetData(), global_Q.GetData(), dim * dim, MPI_DOUBLE, MPI_SUM, fem.H1_fes->GetComm());
+        MPI_Allreduce(
+            local_Q.GetData(), global_Q.GetData(), dim * dim, MPI_DOUBLE,
+            MPI_SUM, fem.mesh->GetComm()
+        );
 
         return global_Q;
     }
@@ -183,7 +274,8 @@ namespace mean_field::physics {
         const mfem::Vector &phys_x
     ) {
         const double r = phys_x.Norml2();
-        if (r < 1e-12) return 0.0;
+        if (r < 1e-12)
+            return 0.0;
 
         const int dim = fem.mesh->Dimension();
 
@@ -197,7 +289,8 @@ namespace mean_field::physics {
             }
         }
 
-        const double l2_contrib = -(utils::G / (2.0 * std::pow(r, 3))) * l2_mult_factor;
+        const double l2_contrib =
+            -(utils::G / (2.0 * std::pow(r, 3))) * l2_mult_factor;
 
         const double l0_contrib = -utils::G * total_mass / r;
 
@@ -211,87 +304,331 @@ namespace mean_field::physics {
         // ==========================================
         // 1. Partially Assemble the High-Order Mass Block
         // ==========================================
-        f.gravity_context.m_form = std::make_unique<mfem::ParBilinearForm>(f.RT_fes.get());
-        f.gravity_context.m_form->SetAssemblyLevel(mfem::AssemblyLevel::PARTIAL);
+        f.gravityContext.m_form =
+            std::make_unique<mfem::ParBilinearForm>(f.gravityFluxFes.get());
+        f.gravityContext.m_form->SetAssemblyLevel(mfem::AssemblyLevel::PARTIAL);
 
         std::unique_ptr<mfem::VectorFEMassIntegrator> hdiv_mass_integrator;
 
         if (f.has_mapping()) {
-            f.gravity_context.mapped_hdiv_mass_coeff = std::make_unique<mapping::MappedHDivMassCoefficient>(*f.mapping, f.mesh->Dimension());
-            hdiv_mass_integrator = std::make_unique<mfem::VectorFEMassIntegrator>(*f.gravity_context.mapped_hdiv_mass_coeff);
+            f.gravityContext.mapped_hdiv_mass_coeff =
+                std::make_unique<mapping::MappedHDivMassCoefficient>(
+                    *f.mapping, f.mesh->Dimension()
+                );
+            hdiv_mass_integrator =
+                std::make_unique<mfem::VectorFEMassIntegrator>(
+                    *f.gravityContext.mapped_hdiv_mass_coeff
+                );
         } else {
-            f.gravity_context.mapped_hdiv_mass_coeff.reset();
-            hdiv_mass_integrator = std::make_unique<mfem::VectorFEMassIntegrator>();
+            f.gravityContext.mapped_hdiv_mass_coeff.reset();
+            hdiv_mass_integrator =
+                std::make_unique<mfem::VectorFEMassIntegrator>();
         }
 
-        const mfem::FiniteElement& hdiv_element = *f.RT_fes->GetTypicalFE();
-        const mfem::ElementTransformation& hdiv_transformation = *f.mesh->GetElementTransformation(0);
-        const quadrature::MappingKind mapping_kind = f.has_mapping() ? quadrature::MappingKind::general : quadrature::MappingKind::none;
+        const mfem::FiniteElement &hdiv_element =
+            *f.gravityFluxFes->GetTypicalFE();
+        const mfem::ElementTransformation &hdiv_transformation =
+            *f.mesh->GetElementTransformation(0);
+        const quadrature::MappingKind mapping_kind =
+            f.has_mapping() ? quadrature::MappingKind::general
+                            : quadrature::MappingKind::none;
 
-        f.quadrature_factory->configure_gravity_hdiv_mass(*hdiv_mass_integrator, quadrature::QuadratureRole::discretization, hdiv_element, hdiv_transformation, utils::DOMAINS::ALL, mapping_kind);
-        f.gravity_context.m_form->AddDomainIntegrator(hdiv_mass_integrator.release());
-        f.gravity_context.m_form->Assemble();
+        f.quadratureFactory->configure_gravity_hdiv_mass(
+            *hdiv_mass_integrator, quadrature::QuadratureRole::discretization,
+            hdiv_element, hdiv_transformation, utils::DOMAINS::ALL, mapping_kind
+        );
+        f.gravityContext.m_form->AddDomainIntegrator(
+            hdiv_mass_integrator.release()
+        );
+
+        f.gravityContext.m_form->Assemble();
 
         // ==========================================
         // 2. Partially Assemble the High-Order Divergence Block
         // ==========================================
-        f.gravity_context.b_form = std::make_unique<mfem::ParMixedBilinearForm>(f.RT_fes.get(), f.L2_fes.get());
-        f.gravity_context.b_form->SetAssemblyLevel(mfem::AssemblyLevel::PARTIAL);
+        f.gravityContext.b_form = std::make_unique<mfem::ParMixedBilinearForm>(
+            f.gravityFluxFes.get(), f.gravityPotentialFes.get()
+        );
+        f.gravityContext.b_form->SetAssemblyLevel(mfem::AssemblyLevel::PARTIAL);
 
-        auto divergence_discretization_integrator = std::make_unique<mfem::VectorFEDivergenceIntegrator>();
-        const mfem::FiniteElement& divergence_discretization_test_element = *f.L2_fes->GetTypicalFE();
+        auto divergence_discretization_integrator =
+            std::make_unique<mfem::VectorFEDivergenceIntegrator>();
+        const mfem::FiniteElement &divergence_discretization_test_element =
+            *f.gravityPotentialFes->GetTypicalFE();
 
-        f.quadrature_factory->configure_gravity_divergence(*divergence_discretization_integrator, quadrature::QuadratureRole::discretization, hdiv_element, divergence_discretization_test_element, hdiv_transformation, utils::DOMAINS::ALL, quadrature::MappingKind::none);
-        f.gravity_context.b_form->AddDomainIntegrator(divergence_discretization_integrator.release());
-        f.gravity_context.b_form->Assemble();
+        f.quadratureFactory->configure_gravity_divergence(
+            *divergence_discretization_integrator,
+            quadrature::QuadratureRole::discretization, hdiv_element,
+            divergence_discretization_test_element, hdiv_transformation,
+            utils::DOMAINS::ALL, quadrature::MappingKind::none
+        );
+        f.gravityContext.b_form->AddDomainIntegrator(
+            divergence_discretization_integrator.release()
+        );
+
+        f.gravityContext.b_form->Assemble();
+
+        MFEM_VERIFY(
+            f.domainMapperStateless != nullptr,
+            "Gravity source partial assembly requires the stateless domain "
+            "mapper."
+        );
+
+        mfem::Vector displacement_true(f.displacementFes->GetTrueVSize());
+        displacement_true = 0.0;
+
+        const mfem::GridFunction *active_displacement =
+            f.mapping->GetDisplacement();
+
+        if (active_displacement != nullptr) {
+            grid_function_to_true_dofs(
+                *f.displacementFes, *active_displacement, displacement_true
+            );
+        }
+
+        auto source_form =
+            std::make_unique<operators::PreparedMappedGravitySourceOperator>(
+                f, *f.domainMapperStateless
+            );
+
+        source_form->Prepare(displacement_true);
+
+        f.gravityContext.source_form = std::move(source_form);
         // ==========================================
         // 3. Assemble Global Block Operator
         // ==========================================
-        f.gravity_context.BT = std::make_unique<mfem::TransposeOperator>(f.gravity_context.b_form.get());
+        f.gravityContext.BT = std::make_unique<mfem::TransposeOperator>(
+            f.gravityContext.b_form.get()
+        );
 
-        f.gravity_context.block_A = std::make_unique<mfem::BlockOperator>(f.gravity_block_true_offsets);
-        f.gravity_context.block_A->SetBlock(0, 0, f.gravity_context.m_form.get());
-        f.gravity_context.block_A->SetBlock(0, 1, f.gravity_context.BT.get());
-        f.gravity_context.block_A->SetBlock(1, 0, f.gravity_context.b_form.get());
+        f.gravityContext.block_A =
+            std::make_unique<mfem::BlockOperator>(f.gravityBlockTrueOffsets);
+        f.gravityContext.block_A->SetBlock(0, 0, f.gravityContext.m_form.get());
+        f.gravityContext.block_A->SetBlock(0, 1, f.gravityContext.BT.get());
+        f.gravityContext.block_A->SetBlock(1, 0, f.gravityContext.b_form.get());
 
         // ==========================================
         // 4. Construct a mapped Schur preconditioner
         // ==========================================
-        mfem::Vector mass_diagonal(f.RT_fes->GetTrueVSize());
-        f.gravity_context.m_form->AssembleDiagonal(mass_diagonal);
+        mfem::Vector mass_diagonal(f.gravityFluxFes->GetTrueVSize());
+        f.gravityContext.m_form->AssembleDiagonal(mass_diagonal);
 
         mfem::Vector inverse_mass_diagonal(mass_diagonal);
 
         for (int i = 0; i < inverse_mass_diagonal.Size(); ++i) {
-            MFEM_VERIFY(std::isfinite(inverse_mass_diagonal(i)) && inverse_mass_diagonal(i) > 0.0, "Mapped RT mass matrix has a non-positive or non-finite diagonal entry.");
+            MFEM_VERIFY(
+                std::isfinite(inverse_mass_diagonal(i)) &&
+                    inverse_mass_diagonal(i) > 0.0,
+                "Mapped RT mass matrix has a non-positive or non-finite "
+                "diagonal "
+                "entry."
+            );
             inverse_mass_diagonal(i) = 1.0 / inverse_mass_diagonal(i);
         }
 
-        mfem::ParMixedBilinearForm b_preconditioner(f.RT_fes.get(), f.L2_fes.get());
-        auto divergence_preconditioner_integrator = std::make_unique<mfem::VectorFEDivergenceIntegrator>();
+        mfem::ParMixedBilinearForm b_preconditioner(
+            f.gravityFluxFes.get(), f.gravityPotentialFes.get()
+        );
+        auto divergence_preconditioner_integrator =
+            std::make_unique<mfem::VectorFEDivergenceIntegrator>();
 
-        const mfem::FiniteElement& divergence_trial_element = *f.RT_fes->GetTypicalFE();
-        const mfem::FiniteElement& divergence_test_element = *f.L2_fes->GetTypicalFE();
-        const mfem::ElementTransformation& divergence_transformation = *f.mesh->GetElementTransformation(0);
+        const mfem::FiniteElement &divergence_trial_element =
+            *f.gravityFluxFes->GetTypicalFE();
+        const mfem::FiniteElement &divergence_test_element =
+            *f.gravityPotentialFes->GetTypicalFE();
+        const mfem::ElementTransformation &divergence_transformation =
+            *f.mesh->GetElementTransformation(0);
 
-        f.quadrature_factory->configure_gravity_divergence(*divergence_preconditioner_integrator, quadrature::QuadratureRole::preconditioner, divergence_trial_element, divergence_test_element, divergence_transformation, utils::DOMAINS::ALL, quadrature::MappingKind::none);
-        b_preconditioner.AddDomainIntegrator(divergence_preconditioner_integrator.release());
+        f.quadratureFactory->configure_gravity_divergence(
+            *divergence_preconditioner_integrator,
+            quadrature::QuadratureRole::preconditioner,
+            divergence_trial_element, divergence_test_element,
+            divergence_transformation, utils::DOMAINS::ALL,
+            quadrature::MappingKind::none
+        );
+        b_preconditioner.AddDomainIntegrator(
+            divergence_preconditioner_integrator.release()
+        );
         b_preconditioner.Assemble();
         b_preconditioner.Finalize();
-        std::unique_ptr<mfem::HypreParMatrix> b_matrix(b_preconditioner.ParallelAssemble());
-        std::unique_ptr<mfem::HypreParMatrix> inverse_mass_b_transpose(b_matrix->Transpose());
+        std::unique_ptr<mfem::HypreParMatrix> b_matrix(
+            b_preconditioner.ParallelAssemble()
+        );
+        std::unique_ptr<mfem::HypreParMatrix> inverse_mass_b_transpose(
+            b_matrix->Transpose()
+        );
 
         inverse_mass_b_transpose->ScaleRows(inverse_mass_diagonal);
 
-        f.gravity_context.Schur.reset(mfem::ParMult(b_matrix.get(), inverse_mass_b_transpose.get()));
+        f.gravityContext.Schur.reset(
+            mfem::ParMult(b_matrix.get(), inverse_mass_b_transpose.get())
+        );
 
         // ==========================================
         // 5. Wire Up the preconditioners
         // ==========================================
-        f.gravity_context.prec_M = std::make_unique<mfem::OperatorJacobiSmoother>(mass_diagonal, empty_tdofs);
-        f.gravity_context.prec_Phi->SetOperator(*f.gravity_context.Schur);
-        f.gravity_context.block_prec->SetDiagonalBlock(0, f.gravity_context.prec_M.get());
-        f.gravity_context.block_prec->SetDiagonalBlock(1, f.gravity_context.prec_Phi.get());
+        f.gravityContext.prec_M =
+            std::make_unique<mfem::OperatorJacobiSmoother>(
+                mass_diagonal, empty_tdofs
+            );
+        f.gravityContext.prec_Phi->SetOperator(*f.gravityContext.Schur);
+        f.gravityContext.block_prec->SetDiagonalBlock(
+            0, f.gravityContext.prec_M.get()
+        );
+        f.gravityContext.block_prec->SetDiagonalBlock(
+            1, f.gravityContext.prec_Phi.get()
+        );
     }
 
-}
+    GravitySolution grav_potential_new(
+        fem::FEM &f,
+        const utils::Args &args,
+        const mfem::GridFunction &rho,
+        const mfem::GridFunction &displacement
+    ) {
+        MFEM_VERIFY(
+            f.mesh != nullptr,
+            "Gravity initialization requires a parallel mesh."
+        );
+        MFEM_VERIFY(
+            f.densityFes != nullptr,
+            "Gravity initialization requires the density finite-element space."
+        );
+        MFEM_VERIFY(
+            f.gravityPotentialFes != nullptr,
+            "Gravity initialization requires the gravity-potential "
+            "finite-element "
+            "space."
+        );
+        MFEM_VERIFY(
+            f.gravityFluxFes != nullptr,
+            "Gravity initialization requires the "
+            "gravity-gradient finite-element space."
+        );
+        MFEM_VERIFY(
+            f.displacementFes != nullptr, "Gravity initialization requires the "
+                                          "displacement finite-element space."
+        );
+        MFEM_VERIFY(
+            f.domainMapperStateless != nullptr,
+            "Gravity initialization requires the stateless domain mapper."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.b_form != nullptr,
+            "Gravity initialization requires the divergence operator."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.BT != nullptr,
+            "Gravity initialization requires the transpose divergence operator."
+        );
+        MFEM_VERIFY(
+            f.gravityContext.block_prec != nullptr,
+            "Gravity initialization requires the gravity block preconditioner."
+        );
+        MFEM_VERIFY(
+            rho.FESpace() == f.densityFes.get(),
+            "Gravity initialization requires density to use the FEM density "
+            "space."
+        );
+        MFEM_VERIFY(
+            displacement.FESpace() == f.displacementFes.get(),
+            "Gravity initialization requires displacement to use the FEM "
+            "Vec_H1 "
+            "space."
+        );
+
+        using form = utils::blocks::gravity_field_form;
+
+        constexpr auto gravity_gradient_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.gradient_term
+            );
+
+        constexpr auto gravity_poisson_residual_block =
+            utils::blocks::get_residual_block<form>(
+                utils::blocks::gravity_field.poisson_term
+            );
+
+        const std::array<int, form::value_block_count> value_sizes{
+            f.densityFes->GetTrueVSize(), f.displacementFes->GetTrueVSize(),
+            f.gravityFluxFes->GetTrueVSize(),
+            f.gravityPotentialFes->GetTrueVSize()
+        };
+
+        const std::array<int, form::residual_block_count> residual_sizes{
+            f.gravityFluxFes->GetTrueVSize(),
+            f.gravityPotentialFes->GetTrueVSize()
+        };
+
+        const utils::blocks::form_layout<form> layout(
+            value_sizes, residual_sizes
+        );
+
+        mfem::Vector density_true;
+        mfem::Vector displacement_true;
+
+        grid_function_to_true_dofs(*f.densityFes, rho, density_true);
+        grid_function_to_true_dofs(
+            *f.displacementFes, displacement, displacement_true
+        );
+
+        operators::context::gravity_field::GravityFieldLinearizationContext
+            linearization_context(f, *f.domainMapperStateless);
+
+        operators::GravityFieldJacobianOperator gravity_jacobian(
+            f, *f.domainMapperStateless, linearization_context,
+            layout.value_offsets(), layout.residual_offsets()
+        );
+
+        operators::GravityFieldOperator gravity_operator(
+            f, *f.domainMapperStateless, linearization_context,
+            layout.value_offsets(), gravity_jacobian
+        );
+
+        operators::context::gravity_field::GravityFieldGeometryContext
+            reduced_geometry_context(f, *f.domainMapperStateless);
+
+        operators::ReducedGravityFieldOperator reduced_operator(
+            gravity_operator, reduced_geometry_context, displacement_true
+        );
+
+        mfem::Vector right_hand_side;
+        reduced_operator.BuildRightHandSide(density_true, right_hand_side);
+
+        MFEM_VERIFY(
+            right_hand_side.Size() == reduced_operator.Height(),
+            "The reduced gravity right-hand side has the wrong size."
+        );
+
+        mfem::BlockVector gravity_state(
+            reduced_operator.GetGravityTrueOffsets()
+        );
+        gravity_state = 0.0;
+
+        mfem::MINRESSolver minres(f.mesh->GetComm());
+        minres.SetOperator(reduced_operator);
+        minres.SetPreconditioner(*f.gravityContext.block_prec);
+        minres.SetRelTol(args.p.rtol);
+        minres.SetAbsTol(args.p.atol);
+        minres.SetMaxIter(args.p.max_iters);
+        minres.SetPrintLevel(1);
+        minres.Mult(right_hand_side, gravity_state);
+
+        MFEM_VERIFY(
+            minres.GetConverged(),
+            "The reduced gravity solve failed to converge."
+        );
+
+        GravitySolution solution(f);
+
+        solution.gradPhi.SetFromTrueDofs(
+            gravity_state.GetBlock(gravity_gradient_residual_block)
+        );
+
+        solution.phi.SetFromTrueDofs(
+            gravity_state.GetBlock(gravity_poisson_residual_block)
+        );
+
+        return solution;
+    }
+} // namespace mean_field::physics

libmeanfield/impl/physics/solid.cpp

@@ -1,17 +1,32 @@
 module;
 #include "mean_field.h"
+#include <array>
 
 module mean_field;
 
 namespace mean_field::physics {
-    double compute_moment_of_inertia(const fem::FEM &fem, const mfem::GridFunction &rho_ref) {
+    double compute_moment_of_inertia(
+        const fem::FEM &fem,
+        const mfem::GridFunction &rho_ref
+    ) {
         double local_I = 0.0;
 
         for (int i = 0; i < fem.mesh->GetNE(); i++) {
-            if (fem.mesh->GetAttribute(i) == 3) continue;
+            if (fem.mesh->GetAttribute(i) == 3)
+                continue;
 
-            mfem::ElementTransformation *T = fem.mesh->GetElementTransformation(i);
-            const mfem::IntegrationRule &ir = *fem.int_rule;
+            mfem::ElementTransformation *T =
+                fem.mesh->GetElementTransformation(i);
+            using DensityField = field::Field<field::Density>;
+            const quadrature::Query query =
+                DensityField::make_query<field::Density::Form::Quadrupole>(
+                    quadrature::QuadratureRole::diagnostic, T->OrderW(),
+                    std::array<int, 1>{2}, utils::DOMAINS::STELLAR,
+                    quadrature::MappingKind::general
+                );
+            const mfem::IntegrationRule &ir =
+                *fem.quadratureFactory->get(query, T->GetGeometryType())
+                     .integration_rule;
 
             for (int j = 0; j < ir.GetNPoints(); j++) {
                 const mfem::IntegrationPoint &ip = ir.IntPoint(j);
@@ -22,7 +37,8 @@ namespace mean_field::physics {
                 mfem::Vector x_phys;
                 fem.mapping->GetPhysicalPoint(*T, ip, x_phys);
 
-                const double r_cyl_sq = x_phys(0) * x_phys(0) + x_phys(1) * x_phys(1);
+                const double r_cyl_sq =
+                    x_phys(0) * x_phys(0) + x_phys(1) * x_phys(1);
                 const double detJ = std::fabs(fem.mapping->ComputeDetJ(*T, ip));
                 const double weight = T->Weight() * ip.weight * detJ;
 
@@ -31,8 +47,10 @@ namespace mean_field::physics {
         }
 
         double global_I = 0.0;
-        MPI_Allreduce(&local_I, &global_I, 1, MPI_DOUBLE, MPI_SUM, fem.H1_fes->GetComm());
+        MPI_Allreduce(
+            &local_I, &global_I, 1, MPI_DOUBLE, MPI_SUM, fem.mesh->GetComm()
+        );
 
         return global_I;
     }
-}
+} // namespace mean_field::physics

libmeanfield/impl/utils/domain.cpp

@@ -11,7 +11,7 @@ namespace mean_field::utils {
         mfem::Vector &x_ref
     ) {
         const int dim = fem.mesh->Dimension();
-        x_ref = x_phys_target;
+        x_ref         = x_phys_target;
 
         mfem::Array<int> init_elem;
         mfem::Array<mfem::IntegrationPoint> init_ip;
@@ -29,8 +29,10 @@ namespace mean_field::utils {
             mfem::Array<mfem::IntegrationPoint> origin_ip;
             fem.mesh->FindPoints(P_origin, origin_elem, origin_ip, false);
 
-            if (origin_elem.Size() > 0 && origin_elem[0] >= 0 && !fem.mapping->IsIdentity()) {
-                mfem::ElementTransformation *T0 = fem.mesh->GetElementTransformation(origin_elem[0]);
+            if (origin_elem.Size() > 0 && origin_elem[0] >= 0 &&
+                fem.mapping->HasDisplacementField()) {
+                mfem::ElementTransformation *T0 =
+                    fem.mesh->GetElementTransformation(origin_elem[0]);
                 T0->SetIntPoint(&origin_ip[0]);
 
                 mfem::DenseMatrix J0(dim, dim), J0_inv(dim, dim);
@@ -81,7 +83,8 @@ namespace mean_field::utils {
 
             if (elem_ids.Size() == 0 || elem_ids[0] < 0) {
                 find_failures++;
-                if (find_failures > 10) return false;
+                if (find_failures > 10)
+                    return false;
 
                 double norm = x_ref.Norml2();
                 if (norm > 1e-15) {
@@ -92,10 +95,11 @@ namespace mean_field::utils {
                 continue;
             }
 
-            int elemID = elem_ids[0];
+            int elemID                       = elem_ids[0];
             const mfem::IntegrationPoint &ip = ips[0];
 
-            mfem::ElementTransformation *T = fem.mesh->GetElementTransformation(elemID);
+            mfem::ElementTransformation *T =
+                fem.mesh->GetElementTransformation(elemID);
             T->SetIntPoint(&ip);
 
             mfem::Vector current_x_phys(dim);
@@ -135,7 +139,8 @@ namespace mean_field::utils {
                 x_ref = x_ref_candidate;
             } else {
                 find_failures++;
-                if (find_failures > 10) return false;
+                if (find_failures > 10)
+                    return false;
                 if (double norm = x_ref.Norml2(); norm > 1e-15) {
                     x_ref *= 0.5 * RADIUS / norm;
                 } else {
@@ -155,7 +160,8 @@ namespace mean_field::utils {
         const mapping::COORDINATE_SPACE rspace
     ) {
         mfem::Vector x_search;
-        if (vspace == mapping::COORDINATE_SPACE::PHYSICAL && fem.has_mapping()) {
+        if (vspace == mapping::COORDINATE_SPACE::PHYSICAL &&
+            fem.has_mapping()) {
             GetReferencePoint(fem, x, x_search);
         } else {
             x_search = x;
@@ -171,18 +177,22 @@ namespace mean_field::utils {
         double local_val = 0.0;
         if (elem_ids.Size() > 0 && elem_ids[0] >= 0) {
             const double val = u.GetValue(elem_ids[0], ips[0]);
-            if (rspace == mapping::COORDINATE_SPACE::PHYSICAL && !fem.has_mapping()) {
-                MFEM_ABORT("Physical evaluation mode requested but no mapping provided. Check domain bounds and mapping setup.");
+            if (rspace == mapping::COORDINATE_SPACE::PHYSICAL &&
+                !fem.has_mapping()) {
+                MFEM_ABORT(
+                    "Physical evaluation mode requested but no mapping "
+                    "provided. Check "
+                    "domain bounds and mapping setup."
+                );
             }
             local_val = val;
         }
 
         double global_val = 0.0;
-        MPI_Allreduce(&local_val, &global_val, 1, MPI_DOUBLE, MPI_MAX, fem.H1_fes->GetComm());
+        MPI_Allreduce(
+            &local_val, &global_val, 1, MPI_DOUBLE, MPI_MAX, fem.mesh->GetComm()
+        );
         return global_val;
     }
 
-
-
-
-}
+} // namespace mean_field::utils

libmeanfield/impl/utils/misc.cpp

@@ -1,6 +1,6 @@
 module;
-#include <mfem.hpp>
 #include <expected>
+#include <mfem.hpp>
 
 module mean_field;
 import :boundary.contexts;
@@ -10,18 +10,22 @@ namespace mean_field::utils {
         DOMAINS lhs,
         DOMAINS rhs
     ) {
-        return static_cast<DOMAINS>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
+        return static_cast<DOMAINS>(
+            static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs)
+        );
     }
 
     DOMAINS operator&(
         DOMAINS lhs,
         DOMAINS rhs
     ) {
-        return static_cast<DOMAINS>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
+        return static_cast<DOMAINS>(
+            static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs)
+        );
     }
 
     void populate_element_mask(
-        const mfem::Mesh* mesh,
+        const mfem::Mesh *mesh,
         const DOMAINS domain,
         mfem::Array<int> &mask
     ) {
@@ -33,7 +37,8 @@ namespace mean_field::utils {
             mask[0] = 1;
         }
 
-        if ((domain & DOMAINS::ENVELOPE) == DOMAINS::ENVELOPE && max_attr >= 2) {
+        if ((domain & DOMAINS::ENVELOPE) == DOMAINS::ENVELOPE &&
+            max_attr >= 2) {
             mask[1] = 1;
         }
 
@@ -59,7 +64,8 @@ namespace mean_field::utils {
 
                 for (int j = 0; j < dofs.Size(); j++) {
                     int index = dofs[j];
-                    if (index < 0) index = -1 - index;
+                    if (index < 0)
+                        index = -1 - index;
                     vdof_marker[index] = 1;
                 }
             }
@@ -68,23 +74,28 @@ namespace mean_field::utils {
         fes->MarkerToList(vdof_marker, ess_tdof);
     }
 
-
-    std::expected<boundary::Bounds, boundary::BoundsError> discover_bounds(
+    std::expected<
+        boundary::Bounds,
+        boundary::BoundsError>
+    discover_bounds(
         const mfem::Mesh *mesh,
         const int vacuum_attr
     ) {
         double local_min_r = std::numeric_limits<double>::max();
         double local_max_r = -std::numeric_limits<double>::max();
-        bool found_vacuum = false;
+        bool found_vacuum  = false;
 
         for (int i = 0; i < mesh->GetNE(); ++i) {
             if (mesh->GetAttribute(i) == vacuum_attr) {
                 found_vacuum = true;
                 mfem::Array<int> vertices;
                 mesh->GetElementVertices(i, vertices);
-                for (const int v: vertices) {
+                for (const int v : vertices) {
                     const double *coords = mesh->GetVertex(v);
-                    double r = std::sqrt(coords[0] * coords[0] + coords[1] * coords[1] + coords[2] * coords[2]);
+                    double r             = std::sqrt(
+                        coords[0] * coords[0] + coords[1] * coords[1] +
+                        coords[2] * coords[2]
+                    );
                     local_min_r = std::min(local_min_r, r);
                     local_max_r = std::max(local_max_r, r);
                 }
@@ -93,16 +104,22 @@ namespace mean_field::utils {
 
         double global_min_r, global_max_r;
         int global_found_vacuum;
-        int l_found = found_vacuum ? 1 : 0;
+        int l_found   = found_vacuum ? 1 : 0;
 
         MPI_Comm comm = MPI_COMM_WORLD;
         if (const auto *pmesh = dynamic_cast<const mfem::ParMesh *>(mesh)) {
             comm = pmesh->GetComm();
         }
 
-        MPI_Allreduce(&local_min_r, &global_min_r, 1, MPI_DOUBLE, MPI_MIN, comm);
-        MPI_Allreduce(&local_max_r, &global_max_r, 1, MPI_DOUBLE, MPI_MAX, comm);
-        MPI_Allreduce(&l_found, &global_found_vacuum, 1, MPI_INT, MPI_MAX, comm);
+        MPI_Allreduce(
+            &local_min_r, &global_min_r, 1, MPI_DOUBLE, MPI_MIN, comm
+        );
+        MPI_Allreduce(
+            &local_max_r, &global_max_r, 1, MPI_DOUBLE, MPI_MAX, comm
+        );
+        MPI_Allreduce(
+            &l_found, &global_found_vacuum, 1, MPI_INT, MPI_MAX, comm
+        );
 
         if (global_found_vacuum) {
             return boundary::Bounds(global_min_r, global_max_r);
@@ -110,15 +127,11 @@ namespace mean_field::utils {
         return std::unexpected(boundary::BoundsError::CANNOT_FIND_VACUUM);
     }
 
-    int get_mesh_order(
-        const mfem::Mesh &mesh
-    ) {
+    int get_mesh_order(const mfem::Mesh &mesh) {
         if (mesh.GetNodes() != nullptr) {
             return mesh.GetNodes()->FESpace()->GetMaxElementOrder();
         }
         return 1;
     }
 
-
-
-}
+} // namespace mean_field::utils