feat(field-support): added field support system, mid migration

currently the barotope and the pressure force operator are migrated to the new support system

libmeanfield/impl/operators/kernels/pressure_force_kernels.cpp

@@ -3,6 +3,7 @@ module;
 #include <array>
 #include <cmath>
 #include <limits>
+#include <optional>
 
 #include <mfem.hpp>
 
@@ -11,20 +12,20 @@ module mean_field;
 import :operators.kernels.pressure_force;
 
 namespace {
+    enum class PressureForceAction { residual, enthalpy, displacement };
+
     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."
+            trueVector.Size() == finiteElementSpace.GetTrueVSize(), "The pressure-force true vector has the wrong size."
         );
 
         localVector.SetSize(finiteElementSpace.GetVSize());
 
-        const mfem::Operator *prolongation =
-            finiteElementSpace.GetProlongationMatrix();
+        const mfem::Operator *prolongation = finiteElementSpace.GetProlongationMatrix();
 
         if (prolongation != nullptr) {
             prolongation->Mult(trueVector, localVector);
@@ -39,15 +40,13 @@ namespace {
         mfem::Vector &trueVector
     ) {
         MFEM_VERIFY(
-            localVector.Size() == finiteElementSpace.GetVSize(),
-            "The pressure-force local vector has the wrong size."
+            localVector.Size() == finiteElementSpace.GetVSize(), "The pressure-force local vector has the wrong size."
         );
 
         trueVector.SetSize(finiteElementSpace.GetTrueVSize());
-        trueVector = 0.0;
+        trueVector                         = 0.0;
 
-        const mfem::Operator *prolongation =
-            finiteElementSpace.GetProlongationMatrix();
+        const mfem::Operator *prolongation = finiteElementSpace.GetProlongationMatrix();
 
         if (prolongation != nullptr) {
             prolongation->MultTranspose(localVector, trueVector);
@@ -68,15 +67,14 @@ namespace {
         }
 
         if (ordering == mfem::Ordering::byVDIM) {
-            return component + scalarDof * dimension;
+            return scalarDof * dimension + component;
         }
+
         MFEM_ABORT("The displacement space uses an unsupported ordering.");
         return -1;
     }
 
-    [[nodiscard]] int get_pressure_extra_order(
-        const mean_field::physics::PolytropicBarotrope &barotrope
-    ) {
+    [[nodiscard]] int get_pressure_extra_order(const mean_field::eos::Polytrope &barotrope) {
         /*
          * Pressure has the enthalpy dependence
          *
@@ -87,15 +85,11 @@ namespace {
          * contribution is therefore n times that order.
          */
         const double extraOrder =
-            barotrope.polytropic_index() *
-            static_cast<double>(
-                mean_field::field::Enthalpy::Scalar::familyOrder
-            );
+            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()),
+                extraOrder <= static_cast<double>(std::numeric_limits<int>::max()),
             "The pressure EOS effective polynomial order is invalid."
         );
 
@@ -104,44 +98,37 @@ namespace {
 
     [[nodiscard]] const mfem::IntegrationRule &get_pressure_force_rule(
         const mean_field::fem::FEM &f,
-        const mean_field::physics::PolytropicBarotrope &barotrope,
+        const mean_field::eos::Polytrope &barotrope,
         const mfem::FiniteElement &enthalpyElement,
         const mfem::FiniteElement &displacementElement,
         const mfem::ElementTransformation &transformation
     ) {
-        using EnthalpyField =
-            mean_field::field::Field<mean_field::field::Enthalpy>;
+        using EnthalpyField = mean_field::field::Field<mean_field::field::Enthalpy>;
 
         MFEM_VERIFY(
-            enthalpyElement.GetOrder() ==
-                mean_field::field::Enthalpy::Scalar::familyOrder,
+            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,
+            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::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());
+        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."
+            rule.integration_rule != nullptr, "The quadrature policy did not return a pressure-force "
+                                              "integration rule."
         );
 
         return *rule.integration_rule;
@@ -153,38 +140,31 @@ namespace {
         const mfem::Vector &enthalpyTrue,
         const mfem::Vector &displacementTrue
     ) {
+        MFEM_VERIFY(f.mesh != nullptr, "The pressure-force kernel requires a mesh.");
+
         MFEM_VERIFY(
-            f.mesh != nullptr, "The pressure-force kernel requires a mesh."
+            f.enthalpyFes != nullptr, "The pressure-force kernel requires the enthalpy "
+                                      "finite-element space."
         );
 
         MFEM_VERIFY(
-            f.enthalpyFes != nullptr,
-            "The pressure-force kernel requires the enthalpy "
-            "finite-element space."
+            f.displacementFes != nullptr, "The pressure-force kernel requires the displacement "
+                                          "finite-element space."
         );
 
         MFEM_VERIFY(
-            f.displacementFes != nullptr,
-            "The pressure-force kernel requires the displacement "
-            "finite-element space."
+            f.compactificationFes != nullptr, "The pressure-force kernel requires the compactification "
+                                              "finite-element space."
         );
 
         MFEM_VERIFY(
-            f.compactificationFes != nullptr,
-            "The pressure-force kernel requires the compactification "
-            "finite-element space."
+            f.compactificationCoordinate != nullptr, "The pressure-force kernel requires the compactification "
+                                                     "coordinate."
         );
 
         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."
+            f.quadratureFactory != nullptr, "The pressure-force kernel requires the quadrature "
+                                            "rule factory."
         );
 
         MFEM_VERIFY(
@@ -204,73 +184,105 @@ namespace {
         );
 
         MFEM_VERIFY(
-            f.displacementFes->GetVDim() == f.mesh->Dimension(),
-            "The displacement vector dimension does not match the "
-            "mesh dimension."
+            f.displacementFes->GetVDim() == f.mesh->Dimension(), "The displacement vector dimension does not match the "
+                                                                 "mesh dimension."
         );
 
+        /*
+         * ElementDisplacementDataFromElementVDofs currently consumes the
+         * registered byNODES layout. Keep this explicit so a future
+         * registry change fails immediately rather than silently
+         * corrupting the geometry.
+         */
         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,
+    void apply_pressure_force_action(
+        const mean_field::fem::FEM &f,
+        const mean_field::mapping::DomainMapperStateless &domainMapper,
+        const mean_field::eos::Polytrope &barotrope,
+        const PressureForceAction pressureForceAction,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector *enthalpyVariationTrue,
+        const mfem::Vector *displacementVariationTrue,
         const mfem::Vector &displacementTrue,
-        mfem::Vector &residualTrue
+        mfem::Vector &actionTrue
     ) {
-        validate_inputs(f, domainMapper, enthalpyTrue, displacementTrue);
+        validate_inputs(f, domainMapper, baseEnthalpyTrue, displacementTrue);
 
-        mfem::Vector enthalpyLocal;
+        if (pressureForceAction == PressureForceAction::enthalpy) {
+            MFEM_VERIFY(
+                enthalpyVariationTrue != nullptr && enthalpyVariationTrue->Size() == f.enthalpyFes->GetTrueVSize(),
+                "The pressure-force enthalpy variation has the wrong size."
+            );
+        }
+
+        if (pressureForceAction == PressureForceAction::displacement) {
+            MFEM_VERIFY(
+                displacementVariationTrue != nullptr &&
+                    displacementVariationTrue->Size() == f.displacementFes->GetTrueVSize(),
+                "The pressure-force displacement variation has the wrong "
+                "size."
+            );
+        }
+
+        mfem::Vector baseEnthalpyLocal;
+        mfem::Vector enthalpyVariationLocal;
         mfem::Vector displacementLocal;
+        mfem::Vector displacementVariationLocal;
 
-        true_to_local(*f.enthalpyFes, enthalpyTrue, enthalpyLocal);
+        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 localResidual(f.displacementFes->GetVSize());
-        localResidual = 0.0;
+        if (displacementVariationTrue != nullptr) {
+            true_to_local(*f.displacementFes, *displacementVariationTrue, displacementVariationLocal);
+        }
 
-        mapping::DomainMapperStateless::Workspace workspace(
-            f.mesh->Dimension()
-        );
+        mfem::Vector localAction(f.displacementFes->GetVSize());
+        localAction = 0.0;
 
-        mfem::Array<int> enthalpyDofs;
+        mean_field::mapping::DomainMapperStateless::Workspace workspace(f.mesh->Dimension());
+
+        mfem::Array<int> enthalpyDofsofs;
         mfem::Array<int> displacementDofs;
         mfem::Array<int> compactificationDofs;
 
-        mfem::Vector elementEnthalpy;
+        mfem::Vector elementBaseEnthalpy;
+        mfem::Vector elementEnthalpyVariation;
         mfem::Vector elementDisplacement;
+        mfem::Vector elementDisplacementVariation;
         mfem::Vector elementCompactification;
-        mfem::Vector elementResidual;
+        mfem::Vector elementAction;
         mfem::Vector enthalpyShape;
 
+        mfem::Array<int> enthalpyDofs;
+
         mfem::DenseMatrix displacementDShapeReference;
         mfem::DenseMatrix displacementDShapePhysical;
+        mfem::DenseMatrix displacementDShapePhysicalVariation;
 
-        mapping::VolumeMappingContext mappingContext;
+        mean_field::mapping::VolumeMappingContext mappingContext;
 
-        const int dimension       = f.mesh->Dimension();
-        const int vacuumAttribute = domainMapper.GetVacuumElementAttribute();
+        const int dimension                             = f.mesh->Dimension();
+        const int vacuumAttribute                       = domainMapper.GetVacuumElementAttribute();
 
-        const mfem::Ordering::Type displacementOrdering =
-            f.displacementFes->GetOrdering();
+        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::ElementTransformation *transformation = f.mesh->GetElementTransformation(elementId);
 
             MFEM_VERIFY(
-                transformation != nullptr,
-                "The pressure-force kernel received a null element "
-                "transformation."
+                transformation != nullptr, "The pressure-force kernel received a null element "
+                                           "transformation."
             );
 
             /*
@@ -281,128 +293,131 @@ namespace mean_field::operators::kernels {
                 continue;
             }
 
-            const mfem::FiniteElement &enthalpyElement =
-                *f.enthalpyFes->GetFE(elementId);
+            const mfem::FiniteElement &enthalpyElement         = *f.enthalpyFes->GetFE(elementId);
 
-            const mfem::FiniteElement &displacementElement =
-                *f.displacementFes->GetFE(elementId);
+            const mfem::FiniteElement &displacementElement     = *f.displacementFes->GetFE(elementId);
 
-            const mfem::FiniteElement &compactificationElement =
-                *f.compactificationFes->GetFE(elementId);
+            const mfem::FiniteElement &compactificationElement = *f.compactificationFes->GetFE(elementId);
 
-            mfem::DofTransformation *enthalpyDofTransformation =
-                f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
+            mfem::DofTransformation *enthalpyDofTransformation = f.enthalpyFes->GetElementDofs(elementId, enthalpyDofs);
 
             mfem::DofTransformation *displacementDofTransformation =
                 f.displacementFes->GetElementVDofs(elementId, displacementDofs);
 
             mfem::DofTransformation *compactificationDofTransformation =
-                f.compactificationFes->GetElementDofs(
-                    elementId, compactificationDofs
-                );
+                f.compactificationFes->GetElementDofs(elementId, compactificationDofs);
 
-            enthalpyLocal.GetSubVector(enthalpyDofs, elementEnthalpy);
+            baseEnthalpyLocal.GetSubVector(enthalpyDofs, elementBaseEnthalpy);
 
-            displacementLocal.GetSubVector(
-                displacementDofs, elementDisplacement
-            );
+            if (enthalpyVariationTrue != nullptr) {
+                enthalpyVariationLocal.GetSubVector(enthalpyDofs, elementEnthalpyVariation);
+            }
 
-            f.compactificationCoordinate->GetSubVector(
-                compactificationDofs, elementCompactification
-            );
+            displacementLocal.GetSubVector(displacementDofs, elementDisplacement);
+
+            if (displacementVariationTrue != nullptr) {
+                displacementVariationLocal.GetSubVector(displacementDofs, elementDisplacementVariation);
+            }
+
+            f.compactificationCoordinate->GetSubVector(compactificationDofs, elementCompactification);
 
             if (enthalpyDofTransformation != nullptr) {
-                enthalpyDofTransformation->InvTransformPrimal(elementEnthalpy);
+                enthalpyDofTransformation->InvTransformPrimal(elementBaseEnthalpy);
+
+                if (enthalpyVariationTrue != nullptr) {
+                    enthalpyDofTransformation->InvTransformPrimal(elementEnthalpyVariation);
+                }
             }
 
             if (displacementDofTransformation != nullptr) {
-                displacementDofTransformation->InvTransformPrimal(
-                    elementDisplacement
-                );
+                displacementDofTransformation->InvTransformPrimal(elementDisplacement);
+
+                if (displacementVariationTrue != nullptr) {
+                    displacementDofTransformation->InvTransformPrimal(elementDisplacementVariation);
+                }
             }
 
             if (compactificationDofTransformation != nullptr) {
-                compactificationDofTransformation->InvTransformPrimal(
-                    elementCompactification
-                );
+                compactificationDofTransformation->InvTransformPrimal(elementCompactification);
             }
 
-            const mapping::ElementDisplacementData displacementData =
-                mapping::ElementDisplacementDataFromElementVDofs(
-                    displacementElement, elementDisplacement
-                );
+            const mean_field::mapping::ElementDisplacementData displacementData =
+                mean_field::mapping::ElementDisplacementDataFromElementVDofs(displacementElement, elementDisplacement);
 
-            const mapping::ElementCompactificationData compactificationData(
+            const mean_field::mapping::ElementCompactificationData compactificationData(
                 compactificationElement, elementCompactification
             );
 
-            const mapping::ElementMappingData mappingData{
-                .displacement     = displacementData,
-                .compactification = compactificationData
+            const mean_field::mapping::ElementMappingData mappingData{
+                .displacement = displacementData, .compactification = compactificationData
             };
 
+            std::optional<mean_field::mapping::ElementDisplacementData> displacementVariationData;
+
+            if (displacementVariationTrue != nullptr) {
+                displacementVariationData.emplace(
+                    mean_field::mapping::ElementDisplacementDataFromElementVDofs(
+                        displacementElement, elementDisplacementVariation
+                    )
+                );
+            }
+
             const int scalarDisplacementDofCount = displacementElement.GetDof();
 
             MFEM_VERIFY(
-                displacementDofs.Size() ==
-                    scalarDisplacementDofCount * dimension,
+                displacementDofs.Size() == scalarDisplacementDofCount * dimension,
                 "The pressure-force element displacement vector has "
                 "the wrong size."
             );
 
             enthalpyShape.SetSize(enthalpyElement.GetDof());
 
-            displacementDShapeReference.SetSize(
-                scalarDisplacementDofCount, dimension
-            );
+            displacementDShapeReference.SetSize(scalarDisplacementDofCount, dimension);
 
-            displacementDShapePhysical.SetSize(
-                scalarDisplacementDofCount, dimension
-            );
+            displacementDShapePhysical.SetSize(scalarDisplacementDofCount, dimension);
 
-            elementResidual.SetSize(displacementDofs.Size());
-            elementResidual = 0.0;
+            displacementDShapePhysicalVariation.SetSize(scalarDisplacementDofCount, dimension);
+
+            elementAction.SetSize(displacementDofs.Size());
+            elementAction = 0.0;
 
             const mfem::IntegrationRule &integrationRule =
-                get_pressure_force_rule(
-                    f, barotrope, enthalpyElement, displacementElement,
-                    *transformation
-                );
+                get_pressure_force_rule(f, barotrope, enthalpyElement, displacementElement, *transformation);
 
-            for (int quadratureIndex = 0;
-                 quadratureIndex < integrationRule.GetNPoints();
-                 ++quadratureIndex) {
-                const mfem::IntegrationPoint &integrationPoint =
-                    integrationRule.IntPoint(quadratureIndex);
+            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
-                    );
+                const mean_field::mapping::MappingStatus mappingStatus = domainMapper.EvaluateVolume(
+                    mappingData, *transformation, integrationPoint, workspace, mappingContext
+                );
 
                 MFEM_VERIFY(
-                    mappingStatus == mapping::MappingStatus::valid,
+                    mappingStatus == mean_field::mapping::MappingStatus::valid,
                     "Stateless mapping failed in the pressure-force "
                     "kernel. Element: "
-                        << elementId
-                        << ", attribute: " << transformation->Attribute
-                        << ", quadrature point: " << quadratureIndex
-                        << ", status: " << static_cast<int>(mappingStatus)
+                        << elementId << ", attribute: " << transformation->Attribute
+                        << ", quadrature point: " << quadratureIndex << ", status: " << static_cast<int>(mappingStatus)
                 );
 
                 enthalpyElement.CalcShape(integrationPoint, enthalpyShape);
 
-                const double enthalpyValue = elementEnthalpy * enthalpyShape;
+                const double enthalpyValue = elementBaseEnthalpy * enthalpyShape;
 
-                const double pressureValue =
-                    barotrope.pressure_from_enthalpy(enthalpyValue);
+                double pressureFactor      = 0.0;
 
-                displacementElement.CalcDShape(
-                    integrationPoint, displacementDShapeReference
-                );
+                if (pressureForceAction == PressureForceAction::residual ||
+                    pressureForceAction == PressureForceAction::displacement) {
+                    pressureFactor = barotrope.pressure_from_enthalpy(enthalpyValue);
+                } else {
+                    const double enthalpyVariationValue = elementEnthalpyVariation * enthalpyShape;
+
+                    pressureFactor =
+                        barotrope.pressure_derivative_from_enthalpy(enthalpyValue) * enthalpyVariationValue;
+                }
+
+                displacementElement.CalcDShape(integrationPoint, displacementDShapeReference);
 
                 /*
                  * Row i of DShape is grad_reference(N_i). Multiplication
@@ -411,17 +426,45 @@ namespace mean_field::operators::kernels {
                  *     grad_physical(N_i)
                  *       = grad_reference(N_i) J^{-1}.
                  */
-                mfem::Mult(
-                    displacementDShapeReference,
-                    mappingContext.quadrature.J_inv, displacementDShapePhysical
-                );
+                mfem::Mult(displacementDShapeReference, mappingContext.quadrature.J_inv, displacementDShapePhysical);
 
-                const double weightedPressure =
-                    pressureValue * mappingContext.quadrature.weight;
+                std::optional<mean_field::mapping::VolumeMappingVariation> mappingVariation;
+
+                if (pressureForceAction == PressureForceAction::displacement) {
+                    mappingVariation.emplace();
+
+                    const mean_field::mapping::MappingStatus variationStatus = domainMapper.EvaluateVolumeVariation(
+                        mappingData, *displacementVariationData, *transformation, integrationPoint, mappingContext,
+                        workspace, *mappingVariation
+                    );
+
+                    MFEM_VERIFY(
+                        variationStatus == mean_field::mapping::MappingStatus::valid,
+                        "Stateless mapping variation failed in the "
+                        "pressure-force kernel. Element: "
+                            << elementId << ", attribute: " << transformation->Attribute << ", quadrature point: "
+                            << quadratureIndex << ", status: " << static_cast<int>(variationStatus)
+                    );
+
+                    /*
+                     * Differentiating
+                     *
+                     *     grad_x(N_i) = grad_reference(N_i) J^{-1}
+                     *
+                     * at the frozen base geometry gives the physical
+                     * test-gradient variation used by the geometric
+                     * pressure block.
+                     */
+                    mfem::Mult(
+                        displacementDShapeReference, mappingVariation->inverse_element_jacobian_variation,
+                        displacementDShapePhysicalVariation
+                    );
+                }
+
+                const double weightedPressureFactor = pressureFactor * mappingContext.quadrature.weight;
 
                 MFEM_VERIFY(
-                    std::isfinite(pressureValue) &&
-                        std::isfinite(weightedPressure),
+                    std::isfinite(pressureFactor) && std::isfinite(weightedPressureFactor),
                     "The pressure-force kernel encountered a non-finite "
                     "quadrature value."
                 );
@@ -436,29 +479,96 @@ namespace mean_field::operators::kernels {
                  *     R_(i,c)
                  *       = -integral P partial_c N_i dV.
                  */
-                for (int scalarDof = 0; scalarDof < scalarDisplacementDofCount;
-                     ++scalarDof) {
-                    for (int component = 0; component < dimension;
-                         ++component) {
+                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
+                            displacementOrdering, scalarDof, component, scalarDisplacementDofCount, dimension
                         );
 
-                        elementResidual(vectorDof) -=
-                            weightedPressure *
-                            displacementDShapePhysical(scalarDof, component);
+                        if (pressureForceAction == PressureForceAction::displacement) {
+                            /*
+                             * Differentiate the complete discrete factor
+                             *
+                             *     grad_x(N_i) dV_x.
+                             *
+                             * The enthalpy DOFs, and therefore P(h), are
+                             * frozen in this Jacobian column.
+                             */
+                            const double gradientWeightVariation =
+                                mappingContext.quadrature.weight *
+                                    displacementDShapePhysicalVariation(scalarDof, component) +
+                                mappingVariation->weight_variation * displacementDShapePhysical(scalarDof, component);
+
+                            const double contribution = pressureFactor * gradientWeightVariation;
+
+                            MFEM_VERIFY(
+                                std::isfinite(gradientWeightVariation) && std::isfinite(contribution),
+                                "The pressure-force geometry action "
+                                "encountered a non-finite contribution."
+                            );
+
+                            elementAction(vectorDof) -= contribution;
+                        } else {
+                            elementAction(vectorDof) -=
+                                weightedPressureFactor * displacementDShapePhysical(scalarDof, component);
+                        }
                     }
                 }
             }
 
             if (displacementDofTransformation != nullptr) {
-                displacementDofTransformation->TransformDual(elementResidual);
+                displacementDofTransformation->TransformDual(elementAction);
             }
 
-            localResidual.AddElementVector(displacementDofs, elementResidual);
+            localAction.AddElementVector(displacementDofs, elementAction);
         }
 
-        local_to_true(*f.displacementFes, localResidual, residualTrue);
+        local_to_true(*f.displacementFes, localAction, actionTrue);
     }
-} // namespace mean_field::operators::kernels
+} // namespace
+
+namespace mean_field::operators::kernels {
+    void apply_pressure_force_residual(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const eos::Polytrope &barotrope,
+        const mfem::Vector &enthalpyTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &residualTrue
+    ) {
+        apply_pressure_force_action(
+            f, domainMapper, barotrope, PressureForceAction::residual, enthalpyTrue, nullptr, nullptr, displacementTrue,
+            residualTrue
+        );
+    }
+
+    void apply_pressure_force_enthalpy_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const eos::Polytrope &barotrope,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &enthalpyVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &actionTrue
+    ) {
+        apply_pressure_force_action(
+            f, domainMapper, barotrope, PressureForceAction::enthalpy, baseEnthalpyTrue, &enthalpyVariationTrue,
+            nullptr, displacementTrue, actionTrue
+        );
+    }
+
+    void apply_pressure_force_displacement_action(
+        const fem::FEM &f,
+        const mapping::DomainMapperStateless &domainMapper,
+        const eos::Polytrope &barotrope,
+        const mfem::Vector &baseEnthalpyTrue,
+        const mfem::Vector &displacementVariationTrue,
+        const mfem::Vector &displacementTrue,
+        mfem::Vector &actionTrue
+    ) {
+        apply_pressure_force_action(
+            f, domainMapper, barotrope, PressureForceAction::displacement, baseEnthalpyTrue, nullptr,
+            &displacementVariationTrue, displacementTrue, actionTrue
+        );
+    }
+} // namespace mean_field::operators::kernels