module;

#include <algorithm>
#include <cmath>
#include <format>
#include <limits>
#include <optional>
#include <stdexcept>
#include <utility>
#include <vector>

#include <mfem.hpp>
#include <mpi.h>

module mean_field;

import :deformation.radial_extensions;

namespace mean_field::deformation {
    namespace {
        struct LocatedBoundaryPoint final {
            int boundaryElement{-1};
            mfem::IntegrationPoint integrationPoint;
            double residualNorm{std::numeric_limits<double>::infinity()};
        };

        [[nodiscard]] InteriorDeformationExtensionDescriptor
        powerLawInteriorDescriptor(const int spatialDimension) noexcept {
            return {
                .name                        = "PowerLawRadialInteriorExtension",
                .spatialDimension            = spatialDimension,
                .linearOnReferenceGeometry   = true,
                .requiresRadialFoliation     = true,
                .requiresAuxiliarySolve      = false,
                .hasExactDerivativeTranspose = true,
                .hasExactPullbackDerivative  = true,
                .centerBehavior              = InteriorCenterBehavior::FixedAtReferenceCenter
            };
        }

        [[nodiscard]] VacuumDeformationExtensionDescriptor
        fixedInfinityVacuumDescriptor(const int spatialDimension) noexcept {
            return {
                .name                        = "FixedInfinityRadialVacuumExtension",
                .spatialDimension            = spatialDimension,
                .linearOnReferenceGeometry   = true,
                .requiresRadialFoliation     = true,
                .requiresAuxiliarySolve      = false,
                .hasExactDerivativeTranspose = true,
                .hasExactPullbackDerivative  = true,
                .outerBoundaryBehavior       = VacuumOuterBoundaryBehavior::FixedAtReferenceInfinity
            };
        }

        [[nodiscard]] double logicalInfinityRadius(const mfem::Vector &position) {
            double radius = 0.0;
            for (int component = 0; component < position.Size(); ++component) {
                radius = std::max(radius, std::abs(position(component)));
            }
            return radius;
        }

        [[nodiscard]] double euclideanDistance(
            const mfem::Vector &first,
            const mfem::Vector &second
        ) {
            double squaredDistance = 0.0;
            for (int component = 0; component < first.Size(); ++component) {
                const double difference = first(component) - second(component);
                squaredDistance += difference * difference;
            }
            return std::sqrt(squaredDistance);
        }

        [[nodiscard]] mfem::Array<int> buildTrueDofSupport(
            mfem::ParFiniteElementSpace &scalarFiniteElementSpace,
            const mfem::Array<int> &materialMarker
        ) {
            const mfem::Mesh *mesh = scalarFiniteElementSpace.GetMesh();
            if (mesh == nullptr) {
                throw std::invalid_argument("Logical radial extension support compilation requires a mesh.");
            }
            if (materialMarker.Size() != mesh->attributes.Max()) {
                throw std::invalid_argument(
                    "A logical radial extension material marker does not cover every material attribute."
                );
            }

            mfem::Array<int> localDofMarker(scalarFiniteElementSpace.GetVSize());
            localDofMarker = 0;
            mfem::Array<int> elementDofs;

            for (int element = 0; element < mesh->GetNE(); ++element) {
                const int attribute = mesh->GetAttribute(element);
                if (attribute <= 0 || attribute > materialMarker.Size() || materialMarker[attribute - 1] == 0) {
                    continue;
                }

                scalarFiniteElementSpace.GetElementDofs(element, elementDofs);
                for (const int encodedDof : elementDofs) {
                    localDofMarker[mfem::FiniteElementSpace::DecodeDof(encodedDof)] = 1;
                }
            }

            scalarFiniteElementSpace.Synchronize(localDofMarker);
            mfem::Array<int> trueDofMarker(scalarFiniteElementSpace.GetTrueVSize());
            trueDofMarker = 0;

            for (int localDof = 0; localDof < localDofMarker.Size(); ++localDof) {
                if (localDofMarker[localDof] == 0) {
                    continue;
                }
                const int trueDof = scalarFiniteElementSpace.GetLocalTDofNumber(localDof);
                if (trueDof >= 0) {
                    trueDofMarker[trueDof] = 1;
                }
            }

            return trueDofMarker;
        }

        [[nodiscard]] mfem::Vector buildLogicalTrueDofPositions(
            mfem::ParFiniteElementSpace &scalarFiniteElementSpace,
            mfem::ParMesh &logicalReferenceMesh
        ) {
            const mfem::Mesh *physicalMesh = scalarFiniteElementSpace.GetMesh();
            if (physicalMesh == nullptr || physicalMesh->GetNE() != logicalReferenceMesh.GetNE()) {
                throw std::invalid_argument(
                    "Logical radial extension compilation requires paired physical and logical elements."
                );
            }

            const int spatialDimension = logicalReferenceMesh.SpaceDimension();
            const int trueDofCount     = scalarFiniteElementSpace.GetTrueVSize();
            mfem::Vector logicalPositions(spatialDimension * trueDofCount);
            mfem::Array<int> processed(trueDofCount);
            processed = 0;

            mfem::Array<int> elementDofs;
            mfem::Vector logicalPosition(spatialDimension);

            for (int element = 0; element < physicalMesh->GetNE(); ++element) {
                if (physicalMesh->GetElementGeometry(element) != logicalReferenceMesh.GetElementGeometry(element) ||
                    physicalMesh->GetAttribute(element) != logicalReferenceMesh.GetAttribute(element)) {
                    throw std::invalid_argument("A physical element does not match its logical reference element.");
                }

                const mfem::FiniteElement &finiteElement = *scalarFiniteElementSpace.GetFE(element);
                const mfem::IntegrationRule &nodes       = finiteElement.GetNodes();
                scalarFiniteElementSpace.GetElementDofs(element, elementDofs);
                if (nodes.GetNPoints() != elementDofs.Size()) {
                    throw std::invalid_argument(
                        "The scalar companion basis is not nodal on a logical reference element."
                    );
                }

                mfem::ElementTransformation *logicalTransformation =
                    logicalReferenceMesh.GetElementTransformation(element);
                if (logicalTransformation == nullptr) {
                    throw std::invalid_argument("A logical reference element has no transformation.");
                }

                for (int localElementDof = 0; localElementDof < elementDofs.Size(); ++localElementDof) {
                    const int localDof = mfem::FiniteElementSpace::DecodeDof(elementDofs[localElementDof]);
                    const int trueDof  = scalarFiniteElementSpace.GetLocalTDofNumber(localDof);
                    if (trueDof < 0) {
                        continue;
                    }

                    logicalTransformation->Transform(nodes.IntPoint(localElementDof), logicalPosition);
                    if (processed[trueDof] != 0) {
                        mfem::Vector existingPosition(
                            logicalPositions.GetData() + spatialDimension * trueDof, spatialDimension
                        );
                        const double scale = std::max(1.0, logicalInfinityRadius(logicalPosition));
                        if (euclideanDistance(existingPosition, logicalPosition) > 1.0e-12 * scale) {
                            throw std::invalid_argument(
                                "A shared scalar DOF has inconsistent logical reference coordinates."
                            );
                        }
                        continue;
                    }

                    for (int component = 0; component < spatialDimension; ++component) {
                        logicalPositions(spatialDimension * trueDof + component) = logicalPosition(component);
                    }
                    processed[trueDof] = 1;
                }
            }

            for (int trueDof = 0; trueDof < trueDofCount; ++trueDof) {
                if (processed[trueDof] == 0) {
                    throw std::invalid_argument("An owned scalar DOF has no logical reference coordinate.");
                }
            }

            return logicalPositions;
        }

        [[nodiscard]] double boundaryLogicalRadius(
            mfem::ParMesh &logicalReferenceMesh,
            const int boundaryAttribute
        ) {
            double minimumRadius = std::numeric_limits<double>::infinity();
            double maximumRadius = 0.0;
            int sampleCount      = 0;
            mfem::Vector position(logicalReferenceMesh.SpaceDimension());

            for (int boundaryElement = 0; boundaryElement < logicalReferenceMesh.GetNBE(); ++boundaryElement) {
                if (logicalReferenceMesh.GetBdrAttribute(boundaryElement) != boundaryAttribute) {
                    continue;
                }

                mfem::ElementTransformation *transformation =
                    logicalReferenceMesh.GetBdrElementTransformation(boundaryElement);
                const int geometry                    = logicalReferenceMesh.GetBdrElementGeometry(boundaryElement);
                const mfem::IntegrationRule *vertices = mfem::Geometries.GetVertices(geometry);
                if (transformation == nullptr || vertices == nullptr) {
                    throw std::invalid_argument("A logical radial boundary element is incomplete.");
                }

                for (int vertex = 0; vertex < vertices->GetNPoints(); ++vertex) {
                    transformation->Transform(vertices->IntPoint(vertex), position);
                    const double radius = logicalInfinityRadius(position);
                    minimumRadius       = std::min(minimumRadius, radius);
                    maximumRadius       = std::max(maximumRadius, radius);
                    ++sampleCount;
                }
            }

            if (sampleCount == 0 || !(minimumRadius > 0.0)) {
                throw std::invalid_argument("A required logical radial boundary is absent.");
            }
            if (maximumRadius - minimumRadius > 1.0e-12 * std::max(1.0, maximumRadius)) {
                throw std::invalid_argument("A logical radial boundary is not a constant L-infinity-radius surface.");
            }
            return 0.5 * (minimumRadius + maximumRadius);
        }

        [[nodiscard]] LocatedBoundaryPoint locateLogicalBoundaryPoint(
            mfem::ParMesh &logicalReferenceMesh,
            const int boundaryAttribute,
            const mfem::Vector &target
        ) {
            LocatedBoundaryPoint best;
            const double residualTolerance = 2.0e-11 * std::max(1.0, logicalInfinityRadius(target));

            for (int boundaryElement = 0; boundaryElement < logicalReferenceMesh.GetNBE(); ++boundaryElement) {
                if (logicalReferenceMesh.GetBdrAttribute(boundaryElement) != boundaryAttribute) {
                    continue;
                }

                const int geometry = logicalReferenceMesh.GetBdrElementGeometry(boundaryElement);
                if (geometry != mfem::Geometry::SQUARE) {
                    throw std::invalid_argument(
                        "The STROID logical radial foliation currently requires quadrilateral boundary elements."
                    );
                }

                mfem::ElementTransformation *transformation =
                    logicalReferenceMesh.GetBdrElementTransformation(boundaryElement);
                if (transformation == nullptr) {
                    throw std::invalid_argument("A logical boundary element has no transformation.");
                }

                mfem::IntegrationPoint point = mfem::Geometries.GetCenter(geometry);
                mfem::Vector transformed(target.Size());
                mfem::Vector residual(target.Size());
                bool nonsingular = true;

                for (int iteration = 0; iteration < 8; ++iteration) {
                    transformation->Transform(point, transformed);
                    residual = target;
                    residual -= transformed;
                    if (residual.Norml2() <= residualTolerance) {
                        break;
                    }

                    transformation->SetIntPoint(&point);
                    const mfem::DenseMatrix &jacobian = transformation->Jacobian();
                    double normal00                   = 0.0;
                    double normal01                   = 0.0;
                    double normal11                   = 0.0;
                    double right0                     = 0.0;
                    double right1                     = 0.0;

                    for (int component = 0; component < target.Size(); ++component) {
                        normal00 += jacobian(component, 0) * jacobian(component, 0);
                        normal01 += jacobian(component, 0) * jacobian(component, 1);
                        normal11 += jacobian(component, 1) * jacobian(component, 1);
                        right0 += jacobian(component, 0) * residual(component);
                        right1 += jacobian(component, 1) * residual(component);
                    }

                    const double determinant = normal00 * normal11 - normal01 * normal01;
                    if (!(std::abs(determinant) > std::numeric_limits<double>::epsilon())) {
                        nonsingular = false;
                        break;
                    }

                    point.x += (normal11 * right0 - normal01 * right1) / determinant;
                    point.y += (normal00 * right1 - normal01 * right0) / determinant;
                }

                if (!nonsingular || !mfem::Geometry::CheckPoint(geometry, point, 1.0e-10)) {
                    continue;
                }

                transformation->Transform(point, transformed);
                const double residualNorm = euclideanDistance(transformed, target);
                if (residualNorm <= residualTolerance && residualNorm < best.residualNorm) {
                    best.boundaryElement  = boundaryElement;
                    best.integrationPoint = point;
                    best.residualNorm     = residualNorm;
                }
            }

            if (best.boundaryElement < 0) {
                throw std::invalid_argument(
                    std::format(
                        "No logical boundary element contains a projected foliation point on boundary attribute {}.",
                        boundaryAttribute
                    )
                );
            }
            return best;
        }

        void appendSurfaceInterpolationRow(
            mfem::ParFiniteElementSpace &scalarFiniteElementSpace,
            const field::ScalarBoundaryDofMap &stellarSurfaceDofMap,
            const LocatedBoundaryPoint &locatedPoint,
            std::vector<int> &globalCoordinates,
            std::vector<double> &weights
        ) {
            mfem::Array<int> boundaryDofs;
            scalarFiniteElementSpace.GetBdrElementDofs(locatedPoint.boundaryElement, boundaryDofs);
            const mfem::FiniteElement *boundaryElement = scalarFiniteElementSpace.GetBE(locatedPoint.boundaryElement);
            if (boundaryElement == nullptr || boundaryElement->GetDof() != boundaryDofs.Size()) {
                throw std::invalid_argument("The physical surface trace basis is incompatible with its boundary DOFs.");
            }

            mfem::Vector shape(boundaryDofs.Size());
            boundaryElement->CalcShape(locatedPoint.integrationPoint, shape);
            double partitionOfUnity = 0.0;

            for (int localShapeDof = 0; localShapeDof < boundaryDofs.Size(); ++localShapeDof) {
                partitionOfUnity += shape(localShapeDof);
                if (std::abs(shape(localShapeDof)) <= 64.0 * std::numeric_limits<double>::epsilon()) {
                    continue;
                }

                const int localDof = mfem::FiniteElementSpace::DecodeDof(boundaryDofs[localShapeDof]);
                const int trueDof  = scalarFiniteElementSpace.GetLocalTDofNumber(localDof);
                if (trueDof < 0) {
                    throw std::invalid_argument(
                        "Logical surface interpolation across MPI ownership is not implemented yet."
                    );
                }
                const std::optional<int> surfaceDof = stellarSurfaceDofMap.local_boundary_dof(trueDof);
                if (!surfaceDof.has_value()) {
                    throw std::invalid_argument(
                        "A logical surface interpolation basis DOF is absent from the compact surface map."
                    );
                }

                const long long globalCoordinate = stellarSurfaceDofMap.global_boundary_dof(*surfaceDof);
                if (globalCoordinate > std::numeric_limits<int>::max()) {
                    throw std::overflow_error("A global surface coordinate exceeds supported integer indexing.");
                }
                globalCoordinates.push_back(static_cast<int>(globalCoordinate));
                weights.push_back(shape(localShapeDof));
            }

            if (std::abs(partitionOfUnity - 1.0) > 2.0e-12) {
                throw std::invalid_argument("A logical surface interpolation row does not preserve constants.");
            }
        }

        [[nodiscard]] std::vector<int> gatherCounts(
            const int localCount,
            MPI_Comm communicator
        ) {
            int communicatorSize = 0;
            MPI_Comm_size(communicator, &communicatorSize);
            std::vector<int> counts(static_cast<std::size_t>(communicatorSize));
            MPI_Allgather(&localCount, 1, MPI_INT, counts.data(), 1, MPI_INT, communicator);
            return counts;
        }

        [[nodiscard]] std::vector<int> prefixOffsets(const std::vector<int> &counts) {
            std::vector<int> offsets(counts.size());
            int offset = 0;
            for (std::size_t rank = 0; rank < counts.size(); ++rank) {
                offsets[rank] = offset;
                offset += counts[rank];
            }
            return offsets;
        }

        void requireVectorSize(
            const mfem::Vector &vector,
            const int requiredSize,
            const char *name
        ) {
            if (vector.Size() != requiredSize) {
                throw std::invalid_argument(
                    std::format(
                        "{} has size {}, but the prepared logical radial extension requires {}.", name, vector.Size(),
                        requiredSize
                    )
                );
            }
        }

        void gatherSurfaceDisplacement(
            const mfem::Vector &localSurfaceDisplacement,
            mfem::Vector &globalSurfaceDisplacement,
            const std::vector<int> &counts,
            const std::vector<int> &offsets,
            MPI_Comm communicator
        ) {
            MPI_Allgatherv(
                localSurfaceDisplacement.GetData(), localSurfaceDisplacement.Size(), MPI_DOUBLE,
                globalSurfaceDisplacement.GetData(), counts.data(), offsets.data(), MPI_DOUBLE, communicator
            );
        }

        void reduceSurfaceDual(
            const mfem::Vector &localGlobalSurfaceDual,
            mfem::Vector &globalSurfaceDual,
            mfem::Vector &surfaceDisplacementDual,
            const int globalSurfaceDisplacementOffset,
            MPI_Comm communicator
        ) {
            MPI_Allreduce(
                localGlobalSurfaceDual.GetData(), globalSurfaceDual.GetData(), localGlobalSurfaceDual.Size(),
                MPI_DOUBLE, MPI_SUM, communicator
            );
            for (int localDof = 0; localDof < surfaceDisplacementDual.Size(); ++localDof) {
                surfaceDisplacementDual(localDof) = globalSurfaceDual(globalSurfaceDisplacementOffset + localDof);
            }
        }

        [[nodiscard]] int interpolationEntryIndex(
            const std::vector<int> &rowOffsets,
            const int scalarTrueDof,
            const int interpolationEntry
        ) {
            if (scalarTrueDof < 0 || scalarTrueDof + 1 >= static_cast<int>(rowOffsets.size())) {
                throw std::out_of_range("Scalar true DOF is outside the logical radial extension.");
            }
            const int entryCount = rowOffsets[scalarTrueDof + 1] - rowOffsets[scalarTrueDof];
            if (interpolationEntry < 0 || interpolationEntry >= entryCount) {
                throw std::out_of_range("Surface interpolation entry is outside the logical radial extension row.");
            }
            return rowOffsets[scalarTrueDof] + interpolationEntry;
        }

        [[nodiscard]] int mfemByNodesVectorDof(
            const int scalarTrueDof,
            const int component,
            const int scalarTrueDofCount
        ) noexcept {
            return scalarTrueDof + component * scalarTrueDofCount;
        }

        void applySparseForward(
            const int spatialDimension,
            const mfem::Array<int> &support,
            const mfem::Vector &radialWeights,
            const std::vector<int> &rowOffsets,
            const std::vector<int> &surfaceCoordinates,
            const std::vector<double> &surfaceWeights,
            const mfem::Vector &globalSurfaceDisplacement,
            mfem::Vector &volumeDisplacement
        ) {
            volumeDisplacement = 0.0;
            for (int scalarTrueDof = 0; scalarTrueDof < support.Size(); ++scalarTrueDof) {
                if (support[scalarTrueDof] == 0 || radialWeights(scalarTrueDof) == 0.0) {
                    continue;
                }
                for (int component = 0; component < spatialDimension; ++component) {
                    double interpolatedSurfaceDisplacement = 0.0;
                    for (int entry = rowOffsets[scalarTrueDof]; entry < rowOffsets[scalarTrueDof + 1]; ++entry) {
                        interpolatedSurfaceDisplacement +=
                            surfaceWeights[entry] *
                            globalSurfaceDisplacement(spatialDimension * surfaceCoordinates[entry] + component);
                    }
                    volumeDisplacement(mfemByNodesVectorDof(scalarTrueDof, component, support.Size())) =
                        radialWeights(scalarTrueDof) * interpolatedSurfaceDisplacement;
                }
            }
        }

        void applySparseTranspose(
            const int spatialDimension,
            const mfem::Array<int> &support,
            const mfem::Vector &radialWeights,
            const std::vector<int> &rowOffsets,
            const std::vector<int> &surfaceCoordinates,
            const std::vector<double> &surfaceWeights,
            const mfem::Vector &volumeDual,
            mfem::Vector &globalSurfaceDual
        ) {
            globalSurfaceDual = 0.0;
            for (int scalarTrueDof = 0; scalarTrueDof < support.Size(); ++scalarTrueDof) {
                if (support[scalarTrueDof] == 0 || radialWeights(scalarTrueDof) == 0.0) {
                    continue;
                }
                for (int entry = rowOffsets[scalarTrueDof]; entry < rowOffsets[scalarTrueDof + 1]; ++entry) {
                    for (int component = 0; component < spatialDimension; ++component) {
                        globalSurfaceDual(spatialDimension * surfaceCoordinates[entry] + component) +=
                            radialWeights(scalarTrueDof) * surfaceWeights[entry] *
                            volumeDual(mfemByNodesVectorDof(scalarTrueDof, component, support.Size()));
                    }
                }
            }
        }
    } // namespace

    RadialDeformationExtensionCompilationContext::RadialDeformationExtensionCompilationContext(
        mfem::ParFiniteElementSpace &scalarFiniteElementSpace,
        mfem::ParFiniteElementSpace &vectorFiniteElementSpace,
        mfem::ParMesh &logicalReferenceMesh,
        field::ScalarBoundaryDofMap stellarSurfaceDofMap,
        field::ScalarBoundaryDofMap infinitySurfaceDofMap,
        mfem::Array<int> stellarMaterialMarker,
        mfem::Array<int> vacuumMaterialMarker,
        const int stellarSurfaceBoundaryAttribute,
        const int infinitySurfaceBoundaryAttribute
    )
        : m_communicator(scalarFiniteElementSpace.GetComm()) {
        const mfem::Mesh *physicalMesh = scalarFiniteElementSpace.GetMesh();
        if (physicalMesh == nullptr || vectorFiniteElementSpace.GetMesh() != physicalMesh) {
            throw std::invalid_argument(
                "Logical radial extension scalar and vector spaces must share one physical mesh."
            );
        }
        int communicatorSize = 0;
        MPI_Comm_size(m_communicator, &communicatorSize);
        if (communicatorSize != 1) {
            throw std::invalid_argument(
                "Logical radial surface interpolation currently supports one MPI rank; shared interpolation-row "
                "ownership remains deferred."
            );
        }
        if (scalarFiniteElementSpace.Nonconforming() || vectorFiniteElementSpace.Nonconforming() ||
            logicalReferenceMesh.Nonconforming()) {
            throw std::invalid_argument("Logical radial extension compilation currently requires conforming meshes.");
        }

        m_spatialDimension       = physicalMesh->SpaceDimension();
        m_scalarTrueDofCount     = scalarFiniteElementSpace.GetTrueVSize();
        m_volumeDisplacementSize = vectorFiniteElementSpace.GetTrueVSize();
        if (logicalReferenceMesh.SpaceDimension() != m_spatialDimension ||
            logicalReferenceMesh.GetNE() != physicalMesh->GetNE() ||
            logicalReferenceMesh.GetNBE() != physicalMesh->GetNBE()) {
            throw std::invalid_argument("The STROID logical reference mesh does not match the physical mesh topology.");
        }
        for (int boundaryElement = 0; boundaryElement < physicalMesh->GetNBE(); ++boundaryElement) {
            if (logicalReferenceMesh.GetBdrAttribute(boundaryElement) !=
                    physicalMesh->GetBdrAttribute(boundaryElement) ||
                logicalReferenceMesh.GetBdrElementGeometry(boundaryElement) !=
                    physicalMesh->GetBdrElementGeometry(boundaryElement)) {
                throw std::invalid_argument("The STROID logical and physical boundary elements do not correspond.");
            }
        }
        if (scalarFiniteElementSpace.GetVDim() != 1 || vectorFiniteElementSpace.GetVDim() != m_spatialDimension ||
            vectorFiniteElementSpace.GetOrdering() != mfem::Ordering::byNODES ||
            m_volumeDisplacementSize != m_spatialDimension * m_scalarTrueDofCount ||
            vectorFiniteElementSpace.FEColl() != scalarFiniteElementSpace.FEColl()) {
            throw std::invalid_argument(
                "Logical radial extension compilation requires an MFEM byNODES vector space made from its scalar "
                "companion basis."
            );
        }
        if (stellarSurfaceDofMap.volume_true_dof_size() != m_scalarTrueDofCount ||
            infinitySurfaceDofMap.volume_true_dof_size() != m_scalarTrueDofCount) {
            throw std::invalid_argument("Logical radial boundary maps do not match the scalar companion space.");
        }

        m_surfaceDisplacementSize         = m_spatialDimension * stellarSurfaceDofMap.local_size();
        const long long globalSurfaceSize = m_spatialDimension * stellarSurfaceDofMap.global_size();
        const long long globalOffset      = m_spatialDimension * stellarSurfaceDofMap.global_offset();
        if (globalSurfaceSize > std::numeric_limits<int>::max() || globalOffset > std::numeric_limits<int>::max()) {
            throw std::overflow_error("The logical radial extension surface vector exceeds MPI integer indexing.");
        }
        m_globalSurfaceDisplacementSize   = static_cast<int>(globalSurfaceSize);
        m_globalSurfaceDisplacementOffset = static_cast<int>(globalOffset);
        m_surfaceDisplacementCounts       = gatherCounts(m_surfaceDisplacementSize, m_communicator);
        m_surfaceDisplacementOffsets      = prefixOffsets(m_surfaceDisplacementCounts);

        m_stellarSupport                  = buildTrueDofSupport(scalarFiniteElementSpace, stellarMaterialMarker);
        m_vacuumSupport                   = buildTrueDofSupport(scalarFiniteElementSpace, vacuumMaterialMarker);
        const mfem::Vector logicalPositions =
            buildLogicalTrueDofPositions(scalarFiniteElementSpace, logicalReferenceMesh);

        m_stellarSurfaceLogicalRadius  = boundaryLogicalRadius(logicalReferenceMesh, stellarSurfaceBoundaryAttribute);
        m_infinitySurfaceLogicalRadius = boundaryLogicalRadius(logicalReferenceMesh, infinitySurfaceBoundaryAttribute);
        if (!(m_infinitySurfaceLogicalRadius > m_stellarSurfaceLogicalRadius)) {
            throw std::invalid_argument("Logical reference infinity must lie outside the logical stellar surface.");
        }

        m_logicalRadius.SetSize(m_scalarTrueDofCount);
        m_surfaceInterpolationRowOffsets.resize(static_cast<std::size_t>(m_scalarTrueDofCount + 1));
        mfem::Vector logicalPosition(m_spatialDimension);
        mfem::Vector stellarSurfaceTarget(m_spatialDimension);
        mfem::Vector infinitySurfaceTarget(m_spatialDimension);
        const double centerTolerance = 64.0 * std::numeric_limits<double>::epsilon() * m_infinitySurfaceLogicalRadius;
        const double radialTolerance = 128.0 * std::numeric_limits<double>::epsilon() * m_infinitySurfaceLogicalRadius;

        for (int scalarTrueDof = 0; scalarTrueDof < m_scalarTrueDofCount; ++scalarTrueDof) {
            m_surfaceInterpolationRowOffsets[scalarTrueDof] = static_cast<int>(m_surfaceInterpolationWeights.size());
            for (int component = 0; component < m_spatialDimension; ++component) {
                logicalPosition(component) = logicalPositions(m_spatialDimension * scalarTrueDof + component);
            }

            const double radius            = logicalInfinityRadius(logicalPosition);
            m_logicalRadius(scalarTrueDof) = radius;
            if (radius <= centerTolerance) {
                continue;
            }
            if (m_stellarSupport[scalarTrueDof] != 0 && radius > m_stellarSurfaceLogicalRadius + radialTolerance) {
                throw std::invalid_argument("A stellar DOF lies outside the logical stellar surface.");
            }
            if (m_vacuumSupport[scalarTrueDof] != 0 && (radius < m_stellarSurfaceLogicalRadius - radialTolerance ||
                                                        radius > m_infinitySurfaceLogicalRadius + radialTolerance)) {
                throw std::invalid_argument("A vacuum DOF lies outside the logical exterior interval.");
            }

            for (int component = 0; component < m_spatialDimension; ++component) {
                stellarSurfaceTarget(component) = logicalPosition(component) * m_stellarSurfaceLogicalRadius / radius;
            }
            const LocatedBoundaryPoint stellarSurfacePoint =
                locateLogicalBoundaryPoint(logicalReferenceMesh, stellarSurfaceBoundaryAttribute, stellarSurfaceTarget);
            appendSurfaceInterpolationRow(
                scalarFiniteElementSpace, stellarSurfaceDofMap, stellarSurfacePoint,
                m_surfaceInterpolationGlobalCoordinates, m_surfaceInterpolationWeights
            );

            if (m_vacuumSupport[scalarTrueDof] != 0) {
                for (int component = 0; component < m_spatialDimension; ++component) {
                    infinitySurfaceTarget(component) =
                        logicalPosition(component) * m_infinitySurfaceLogicalRadius / radius;
                }
                static_cast<void>(locateLogicalBoundaryPoint(
                    logicalReferenceMesh, infinitySurfaceBoundaryAttribute, infinitySurfaceTarget
                ));
            }
        }
        m_surfaceInterpolationRowOffsets[m_scalarTrueDofCount] = static_cast<int>(m_surfaceInterpolationWeights.size());
    }

    int RadialDeformationExtensionCompilationContext::spatialDimension() const noexcept {
        return m_spatialDimension;
    }

    int RadialDeformationExtensionCompilationContext::surfaceDisplacementSize() const noexcept {
        return m_surfaceDisplacementSize;
    }

    int RadialDeformationExtensionCompilationContext::volumeDisplacementSize() const noexcept {
        return m_volumeDisplacementSize;
    }

    int RadialDeformationExtensionCompilationContext::scalarTrueDofCount() const noexcept {
        return m_scalarTrueDofCount;
    }

    double RadialDeformationExtensionCompilationContext::logicalRadius(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the logical radial compilation context.");
        }
        return m_logicalRadius(scalarTrueDof);
    }

    double RadialDeformationExtensionCompilationContext::stellarSurfaceLogicalRadius() const noexcept {
        return m_stellarSurfaceLogicalRadius;
    }

    double RadialDeformationExtensionCompilationContext::infinitySurfaceLogicalRadius() const noexcept {
        return m_infinitySurfaceLogicalRadius;
    }

    int RadialDeformationExtensionCompilationContext::surfaceInterpolationEntryCount(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the logical radial compilation context.");
        }
        return m_surfaceInterpolationRowOffsets[scalarTrueDof + 1] - m_surfaceInterpolationRowOffsets[scalarTrueDof];
    }

    int RadialDeformationExtensionCompilationContext::surfaceGlobalCoordinate(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationGlobalCoordinates[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }

    double RadialDeformationExtensionCompilationContext::surfaceInterpolationWeight(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationWeights[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }

    PowerLawRadialInteriorExtension::PowerLawRadialInteriorExtension(const double radialPower)
        : m_radialPower(radialPower) {
        validate();
    }

    double PowerLawRadialInteriorExtension::radialPower() const noexcept {
        return m_radialPower;
    }

    InteriorDeformationExtensionDescriptor PowerLawRadialInteriorExtension::descriptor() const noexcept {
        return powerLawInteriorDescriptor(3);
    }

    void PowerLawRadialInteriorExtension::validate() const {
        if (!std::isfinite(m_radialPower) || m_radialPower < 1.0) {
            throw std::invalid_argument("PowerLawRadialInteriorExtension requires a finite radial power at least one.");
        }
    }

    PreparedPowerLawRadialInteriorExtension::PreparedPowerLawRadialInteriorExtension(
        const PowerLawRadialInteriorExtension &extension,
        const RadialDeformationExtensionCompilationContext &context
    )
        : m_descriptor(powerLawInteriorDescriptor(context.m_spatialDimension)),
          m_radialPower(extension.radialPower()),
          m_surfaceDisplacementSize(context.m_surfaceDisplacementSize),
          m_interiorDisplacementSize(context.m_volumeDisplacementSize),
          m_spatialDimension(context.m_spatialDimension),
          m_globalSurfaceDisplacementSize(context.m_globalSurfaceDisplacementSize),
          m_globalSurfaceDisplacementOffset(context.m_globalSurfaceDisplacementOffset),
          m_communicator(context.m_communicator),
          m_stellarSupport(context.m_stellarSupport),
          m_radialWeights(context.m_scalarTrueDofCount),
          m_surfaceInterpolationRowOffsets(context.m_surfaceInterpolationRowOffsets),
          m_surfaceInterpolationGlobalCoordinates(context.m_surfaceInterpolationGlobalCoordinates),
          m_surfaceInterpolationWeights(context.m_surfaceInterpolationWeights),
          m_surfaceDisplacementCounts(context.m_surfaceDisplacementCounts),
          m_surfaceDisplacementOffsets(context.m_surfaceDisplacementOffsets),
          m_globalSurfaceDisplacementWorkspace(context.m_globalSurfaceDisplacementSize),
          m_localGlobalSurfaceDualWorkspace(context.m_globalSurfaceDisplacementSize),
          m_globalSurfaceDualWorkspace(context.m_globalSurfaceDisplacementSize) {
        for (int scalarTrueDof = 0; scalarTrueDof < scalarTrueDofCount(); ++scalarTrueDof) {
            if (m_stellarSupport[scalarTrueDof] == 0 || context.m_logicalRadius(scalarTrueDof) == 0.0) {
                m_radialWeights(scalarTrueDof) = 0.0;
                continue;
            }
            m_radialWeights(scalarTrueDof) =
                std::pow(context.m_logicalRadius(scalarTrueDof) / context.m_stellarSurfaceLogicalRadius, m_radialPower);
        }
    }

    InteriorDeformationExtensionDescriptor PreparedPowerLawRadialInteriorExtension::descriptor() const noexcept {
        return m_descriptor;
    }
    int PreparedPowerLawRadialInteriorExtension::surfaceDisplacementSize() const noexcept {
        return m_surfaceDisplacementSize;
    }
    int PreparedPowerLawRadialInteriorExtension::interiorDisplacementSize() const noexcept {
        return m_interiorDisplacementSize;
    }
    int PreparedPowerLawRadialInteriorExtension::scalarTrueDofCount() const noexcept {
        return m_stellarSupport.Size();
    }
    double PreparedPowerLawRadialInteriorExtension::radialPower() const noexcept {
        return m_radialPower;
    }
    bool PreparedPowerLawRadialInteriorExtension::hasStellarSupport(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared interior extension.");
        }
        return m_stellarSupport[scalarTrueDof] != 0;
    }
    double PreparedPowerLawRadialInteriorExtension::radialWeight(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared interior extension.");
        }
        return m_radialWeights(scalarTrueDof);
    }
    int PreparedPowerLawRadialInteriorExtension::surfaceInterpolationEntryCount(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared interior extension.");
        }
        return m_surfaceInterpolationRowOffsets[scalarTrueDof + 1] - m_surfaceInterpolationRowOffsets[scalarTrueDof];
    }
    int PreparedPowerLawRadialInteriorExtension::surfaceGlobalCoordinate(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationGlobalCoordinates[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }
    double PreparedPowerLawRadialInteriorExtension::surfaceInterpolationWeight(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationWeights[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }

    void PreparedPowerLawRadialInteriorExtension::requireSurfaceSize(const mfem::Vector &vector) const {
        requireVectorSize(vector, surfaceDisplacementSize(), "Surface displacement");
    }
    void PreparedPowerLawRadialInteriorExtension::requireInteriorSize(const mfem::Vector &vector) const {
        requireVectorSize(vector, interiorDisplacementSize(), "Interior displacement");
    }
    void PreparedPowerLawRadialInteriorExtension::applyForward(
        const mfem::Vector &surfaceDisplacement,
        mfem::Vector &interiorDisplacement
    ) const {
        gatherSurfaceDisplacement(
            surfaceDisplacement, m_globalSurfaceDisplacementWorkspace, m_surfaceDisplacementCounts,
            m_surfaceDisplacementOffsets, m_communicator
        );
        applySparseForward(
            m_spatialDimension, m_stellarSupport, m_radialWeights, m_surfaceInterpolationRowOffsets,
            m_surfaceInterpolationGlobalCoordinates, m_surfaceInterpolationWeights,
            m_globalSurfaceDisplacementWorkspace, interiorDisplacement
        );
    }
    void PreparedPowerLawRadialInteriorExtension::applyTranspose(
        const mfem::Vector &interiorDisplacementDual,
        mfem::Vector &surfaceDisplacementDual
    ) const {
        applySparseTranspose(
            m_spatialDimension, m_stellarSupport, m_radialWeights, m_surfaceInterpolationRowOffsets,
            m_surfaceInterpolationGlobalCoordinates, m_surfaceInterpolationWeights, interiorDisplacementDual,
            m_localGlobalSurfaceDualWorkspace
        );
        reduceSurfaceDual(
            m_localGlobalSurfaceDualWorkspace, m_globalSurfaceDualWorkspace, surfaceDisplacementDual,
            m_globalSurfaceDisplacementOffset, m_communicator
        );
    }
    void PreparedPowerLawRadialInteriorExtension::buildInteriorDisplacement(
        const mfem::Vector &surfaceDisplacement,
        mfem::Vector &interiorDisplacement
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireInteriorSize(interiorDisplacement);
        applyForward(surfaceDisplacement, interiorDisplacement);
    }
    void PreparedPowerLawRadialInteriorExtension::applyJacobian(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &surfaceDisplacementDirection,
        mfem::Vector &interiorDisplacementDirection
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireSurfaceSize(surfaceDisplacementDirection);
        requireInteriorSize(interiorDisplacementDirection);
        applyForward(surfaceDisplacementDirection, interiorDisplacementDirection);
    }
    void PreparedPowerLawRadialInteriorExtension::applyJacobianTranspose(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &interiorDisplacementDual,
        mfem::Vector &surfaceDisplacementDual
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireInteriorSize(interiorDisplacementDual);
        requireSurfaceSize(surfaceDisplacementDual);
        applyTranspose(interiorDisplacementDual, surfaceDisplacementDual);
    }
    void PreparedPowerLawRadialInteriorExtension::applyPullbackDerivative(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &surfaceDisplacementDirection,
        const mfem::Vector &interiorDisplacementDual,
        mfem::Vector &surfaceDisplacementDualAction
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireSurfaceSize(surfaceDisplacementDirection);
        requireInteriorSize(interiorDisplacementDual);
        requireSurfaceSize(surfaceDisplacementDualAction);
        surfaceDisplacementDualAction = 0.0;
    }
    PreparedPowerLawRadialInteriorExtension compileInteriorDeformationExtension(
        const PowerLawRadialInteriorExtension &extension,
        const RadialDeformationExtensionCompilationContext &context
    ) {
        extension.validate();
        return PreparedPowerLawRadialInteriorExtension(extension, context);
    }

    VacuumDeformationExtensionDescriptor FixedInfinityRadialVacuumExtension::descriptor() const noexcept {
        return fixedInfinityVacuumDescriptor(3);
    }
    void FixedInfinityRadialVacuumExtension::validate() const {
    }

    PreparedFixedInfinityRadialVacuumExtension::PreparedFixedInfinityRadialVacuumExtension(
        const FixedInfinityRadialVacuumExtension &extension,
        const RadialDeformationExtensionCompilationContext &context
    )
        : m_descriptor(fixedInfinityVacuumDescriptor(context.m_spatialDimension)),
          m_surfaceDisplacementSize(context.m_surfaceDisplacementSize),
          m_vacuumDisplacementSize(context.m_volumeDisplacementSize),
          m_spatialDimension(context.m_spatialDimension),
          m_globalSurfaceDisplacementSize(context.m_globalSurfaceDisplacementSize),
          m_globalSurfaceDisplacementOffset(context.m_globalSurfaceDisplacementOffset),
          m_communicator(context.m_communicator),
          m_vacuumSupport(context.m_vacuumSupport),
          m_radialWeights(context.m_scalarTrueDofCount),
          m_surfaceInterpolationRowOffsets(context.m_surfaceInterpolationRowOffsets),
          m_surfaceInterpolationGlobalCoordinates(context.m_surfaceInterpolationGlobalCoordinates),
          m_surfaceInterpolationWeights(context.m_surfaceInterpolationWeights),
          m_surfaceDisplacementCounts(context.m_surfaceDisplacementCounts),
          m_surfaceDisplacementOffsets(context.m_surfaceDisplacementOffsets),
          m_globalSurfaceDisplacementWorkspace(context.m_globalSurfaceDisplacementSize),
          m_localGlobalSurfaceDualWorkspace(context.m_globalSurfaceDisplacementSize),
          m_globalSurfaceDualWorkspace(context.m_globalSurfaceDisplacementSize) {
        static_cast<void>(extension);
        for (int scalarTrueDof = 0; scalarTrueDof < scalarTrueDofCount(); ++scalarTrueDof) {
            if (m_vacuumSupport[scalarTrueDof] == 0) {
                m_radialWeights(scalarTrueDof) = 0.0;
                continue;
            }
            m_radialWeights(scalarTrueDof) =
                (context.m_infinitySurfaceLogicalRadius - context.m_logicalRadius(scalarTrueDof)) /
                (context.m_infinitySurfaceLogicalRadius - context.m_stellarSurfaceLogicalRadius);
        }
    }

    VacuumDeformationExtensionDescriptor PreparedFixedInfinityRadialVacuumExtension::descriptor() const noexcept {
        return m_descriptor;
    }
    int PreparedFixedInfinityRadialVacuumExtension::surfaceDisplacementSize() const noexcept {
        return m_surfaceDisplacementSize;
    }
    int PreparedFixedInfinityRadialVacuumExtension::vacuumDisplacementSize() const noexcept {
        return m_vacuumDisplacementSize;
    }
    int PreparedFixedInfinityRadialVacuumExtension::scalarTrueDofCount() const noexcept {
        return m_vacuumSupport.Size();
    }
    bool PreparedFixedInfinityRadialVacuumExtension::hasVacuumSupport(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared vacuum extension.");
        }
        return m_vacuumSupport[scalarTrueDof] != 0;
    }
    double PreparedFixedInfinityRadialVacuumExtension::radialWeight(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared vacuum extension.");
        }
        return m_radialWeights(scalarTrueDof);
    }
    int PreparedFixedInfinityRadialVacuumExtension::surfaceInterpolationEntryCount(const int scalarTrueDof) const {
        if (scalarTrueDof < 0 || scalarTrueDof >= scalarTrueDofCount()) {
            throw std::out_of_range("Scalar true DOF is outside the prepared vacuum extension.");
        }
        return m_surfaceInterpolationRowOffsets[scalarTrueDof + 1] - m_surfaceInterpolationRowOffsets[scalarTrueDof];
    }
    int PreparedFixedInfinityRadialVacuumExtension::surfaceGlobalCoordinate(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationGlobalCoordinates[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }
    double PreparedFixedInfinityRadialVacuumExtension::surfaceInterpolationWeight(
        const int scalarTrueDof,
        const int interpolationEntry
    ) const {
        return m_surfaceInterpolationWeights[interpolationEntryIndex(
            m_surfaceInterpolationRowOffsets, scalarTrueDof, interpolationEntry
        )];
    }

    void PreparedFixedInfinityRadialVacuumExtension::requireSurfaceSize(const mfem::Vector &vector) const {
        requireVectorSize(vector, surfaceDisplacementSize(), "Surface displacement");
    }
    void PreparedFixedInfinityRadialVacuumExtension::requireVacuumSize(const mfem::Vector &vector) const {
        requireVectorSize(vector, vacuumDisplacementSize(), "Vacuum displacement");
    }
    void PreparedFixedInfinityRadialVacuumExtension::applyForward(
        const mfem::Vector &surfaceDisplacement,
        mfem::Vector &vacuumDisplacement
    ) const {
        gatherSurfaceDisplacement(
            surfaceDisplacement, m_globalSurfaceDisplacementWorkspace, m_surfaceDisplacementCounts,
            m_surfaceDisplacementOffsets, m_communicator
        );
        applySparseForward(
            m_spatialDimension, m_vacuumSupport, m_radialWeights, m_surfaceInterpolationRowOffsets,
            m_surfaceInterpolationGlobalCoordinates, m_surfaceInterpolationWeights,
            m_globalSurfaceDisplacementWorkspace, vacuumDisplacement
        );
    }
    void PreparedFixedInfinityRadialVacuumExtension::applyTranspose(
        const mfem::Vector &vacuumDisplacementDual,
        mfem::Vector &surfaceDisplacementDual
    ) const {
        applySparseTranspose(
            m_spatialDimension, m_vacuumSupport, m_radialWeights, m_surfaceInterpolationRowOffsets,
            m_surfaceInterpolationGlobalCoordinates, m_surfaceInterpolationWeights, vacuumDisplacementDual,
            m_localGlobalSurfaceDualWorkspace
        );
        reduceSurfaceDual(
            m_localGlobalSurfaceDualWorkspace, m_globalSurfaceDualWorkspace, surfaceDisplacementDual,
            m_globalSurfaceDisplacementOffset, m_communicator
        );
    }
    void PreparedFixedInfinityRadialVacuumExtension::buildVacuumDisplacement(
        const mfem::Vector &surfaceDisplacement,
        mfem::Vector &vacuumDisplacement
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireVacuumSize(vacuumDisplacement);
        applyForward(surfaceDisplacement, vacuumDisplacement);
    }
    void PreparedFixedInfinityRadialVacuumExtension::applyJacobian(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &surfaceDisplacementDirection,
        mfem::Vector &vacuumDisplacementDirection
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireSurfaceSize(surfaceDisplacementDirection);
        requireVacuumSize(vacuumDisplacementDirection);
        applyForward(surfaceDisplacementDirection, vacuumDisplacementDirection);
    }
    void PreparedFixedInfinityRadialVacuumExtension::applyJacobianTranspose(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &vacuumDisplacementDual,
        mfem::Vector &surfaceDisplacementDual
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireVacuumSize(vacuumDisplacementDual);
        requireSurfaceSize(surfaceDisplacementDual);
        applyTranspose(vacuumDisplacementDual, surfaceDisplacementDual);
    }
    void PreparedFixedInfinityRadialVacuumExtension::applyPullbackDerivative(
        const mfem::Vector &surfaceDisplacement,
        const mfem::Vector &surfaceDisplacementDirection,
        const mfem::Vector &vacuumDisplacementDual,
        mfem::Vector &surfaceDisplacementDualAction
    ) const {
        requireSurfaceSize(surfaceDisplacement);
        requireSurfaceSize(surfaceDisplacementDirection);
        requireVacuumSize(vacuumDisplacementDual);
        requireSurfaceSize(surfaceDisplacementDualAction);
        surfaceDisplacementDualAction = 0.0;
    }
    PreparedFixedInfinityRadialVacuumExtension compileVacuumDeformationExtension(
        const FixedInfinityRadialVacuumExtension &extension,
        const RadialDeformationExtensionCompilationContext &context
    ) {
        extension.validate();
        return PreparedFixedInfinityRadialVacuumExtension(extension, context);
    }
} // namespace mean_field::deformation