MeanField/tests/mapping/domain_mapper.cpp

#include <algorithm>
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_floating_point.hpp>
#include <limits>
#include <memory>
#include <mfem.hpp>
#include <stdexcept>
#include <stroid/stroid.h>

import mean_field;
import test_helpers;
using namespace mean_field;
using Catch::Matchers::WithinAbs;

namespace {
    constexpr int dimension    = 3;
    constexpr double tolerance = 1.0e-12;

    std::unique_ptr<const mapping::compactification::ExteriorDomainMap> make_kelvin_compactification() {
        return std::make_unique<mapping::compactification::KelvinCompactification>(
            mapping::compactification::options::KelvinCompactificationOptions{.r_star_ref = 1.0, .r_inf_ref = 4.0}
        );
    }

    mfem::DenseMatrix make_identity_matrix(const int size) {
        mfem::DenseMatrix matrix(size);
        matrix = 0.0;
        for (int i = 0; i < size; ++i)
            matrix(i, i) = 1.0;
        return matrix;
    }

    mfem::Vector make_constant_compactification_dofs(
        const mfem::FiniteElement &element,
        const double value = 0.0
    ) {
        mfem::Vector dofs(element.GetDof());
        dofs = value;
        return dofs;
    }

    template <typename Function>
    mfem::Vector make_compactification_element_dofs(
        const mfem::FiniteElement &element,
        mfem::ElementTransformation &transformation,
        Function &&function
    ) {
        const mfem::IntegrationRule &nodes = element.GetNodes();
        REQUIRE(nodes.GetNPoints() == element.GetDof());

        mfem::Vector dofs(element.GetDof());
        mfem::Vector reference_position(dimension);

        for (int i = 0; i < element.GetDof(); ++i) {
            transformation.Transform(nodes.IntPoint(i), reference_position);
            dofs(i) = function(reference_position);
        }

        return dofs;
    }

    class ElementMappingDataOwner {
    public:
        explicit ElementMappingDataOwner(const mapping::ElementDisplacementData &displacement)
            : m_compactification(
                  displacement.GetElement(),
                  make_constant_compactification_dofs(displacement.GetElement())
              ),
              m_element_data{
                  .displacement     = displacement,
                  .compactification = m_compactification
              } {
        }

        ElementMappingDataOwner(
            const mapping::ElementDisplacementData &displacement,
            const mfem::FiniteElement &compactification_element,
            const mfem::Vector &compactification_dofs
        )
            : m_compactification(
                  compactification_element,
                  compactification_dofs
              ),
              m_element_data{
                  .displacement     = displacement,
                  .compactification = m_compactification
              } {
        }

        ElementMappingDataOwner(const ElementMappingDataOwner &)            = delete;
        ElementMappingDataOwner &operator=(const ElementMappingDataOwner &) = delete;
        ElementMappingDataOwner(ElementMappingDataOwner &&)                 = delete;
        ElementMappingDataOwner &operator=(ElementMappingDataOwner &&)      = delete;

        [[nodiscard]] const mapping::ElementMappingData &Get() const noexcept {
            return m_element_data;
        }

    private:
        mapping::ElementCompactificationData m_compactification;
        mapping::ElementMappingData m_element_data;
    };

    void check_vector(
        const mfem::Vector &actual,
        const mfem::Vector &expected,
        const double comparison_tolerance = tolerance
    ) {
        REQUIRE(actual.Size() == expected.Size());
        for (int i = 0; i < actual.Size(); ++i)
            CHECK_THAT(actual(i), WithinAbs(expected(i), comparison_tolerance));
    }

    void check_matrix(
        const mfem::DenseMatrix &actual,
        const mfem::DenseMatrix &expected,
        const double comparison_tolerance = tolerance
    ) {
        REQUIRE(actual.Height() == expected.Height());
        REQUIRE(actual.Width() == expected.Width());

        for (int i = 0; i < actual.Height(); ++i) {
            for (int j = 0; j < actual.Width(); ++j)
                CHECK_THAT(actual(i, j), WithinAbs(expected(i, j), comparison_tolerance));
        }
    }

    struct SingleElementFixture {
        mfem::Mesh mesh;
        mfem::H1_FECollection displacement_collection;
        mfem::FiniteElementSpace displacement_space;

        SingleElementFixture()
            : mesh(
                  mfem::Mesh::MakeCartesian3D(
                      1,
                      1,
                      1,
                      mfem::Element::HEXAHEDRON,
                      2.0,
                      3.0,
                      4.0
                  )
              ),
              displacement_collection(
                  1,
                  dimension
              ),
              displacement_space(
                  &mesh,
                  &displacement_collection,
                  dimension,
                  mfem::Ordering::byVDIM
              ) {
        }

        [[nodiscard]] const mfem::FiniteElement &GetElement() const {
            return *displacement_space.GetFE(0);
        }

        [[nodiscard]] mfem::Vector MakeZeroElementDofs() const {
            mfem::Vector element_dofs(GetElement().GetDof() * dimension);
            element_dofs = 0.0;
            return element_dofs;
        }
    };

    mfem::Vector make_vector(
        const double x,
        const double y,
        const double z
    ) {
        mfem::Vector vector(3);
        vector(0) = x;
        vector(1) = y;
        vector(2) = z;
        return vector;
    }

    mfem::DenseMatrix make_affine_displacement_gradient() {
        mfem::DenseMatrix gradient(3);
        gradient(0, 0) = 0.10;
        gradient(0, 1) = 0.04;
        gradient(0, 2) = -0.02;
        gradient(1, 0) = -0.03;
        gradient(1, 1) = 0.08;
        gradient(1, 2) = 0.01;
        gradient(2, 0) = 0.02;
        gradient(2, 1) = -0.01;
        gradient(2, 2) = -0.05;
        return gradient;
    }

    mfem::Vector make_affine_element_dofs(
        const mfem::FiniteElement &element,
        mfem::ElementTransformation &transformation,
        const mfem::DenseMatrix &displacement_gradient,
        const mfem::Vector &displacement_offset,
        const mfem::Ordering::Type ordering
    ) {
        const int dof_count                = element.GetDof();
        const int field_dimension          = displacement_offset.Size();
        const mfem::IntegrationRule &nodes = element.GetNodes();

        REQUIRE(nodes.GetNPoints() == dof_count);

        mfem::Vector element_dofs(dof_count * field_dimension);
        mfem::Vector reference_position(field_dimension);
        mfem::Vector displacement(field_dimension);

        for (int i = 0; i < dof_count; ++i) {
            transformation.Transform(nodes.IntPoint(i), reference_position);
            displacement_gradient.Mult(reference_position, displacement);
            displacement += displacement_offset;

            for (int component = 0; component < field_dimension; ++component) {
                const int index =
                    ordering == mfem::Ordering::byNODES ? i + component * dof_count : component + i * field_dimension;
                element_dofs(index) = displacement(component);
            }
        }

        return element_dofs;
    }

    mfem::DenseMatrix make_deformation_jacobian(const mfem::DenseMatrix &displacement_gradient) {
        mfem::DenseMatrix deformation_jacobian = make_identity_matrix(displacement_gradient.Height());
        deformation_jacobian.Add(1.0, displacement_gradient);
        return deformation_jacobian;
    }

    mfem::Vector evaluate_affine_physical_position(
        const mfem::Vector &reference_position,
        const mfem::DenseMatrix &displacement_gradient,
        const mfem::Vector &displacement_offset
    ) {
        mfem::Vector physical_position(reference_position);
        mfem::Vector displacement(reference_position.Size());
        displacement_gradient.Mult(reference_position, displacement);
        physical_position += displacement;
        physical_position += displacement_offset;
        return physical_position;
    }

    void check_point_context(
        const mapping::MappingPointContext &actual,
        const mapping::MappingPointContext &expected,
        const double comparison_tolerance = tolerance
    ) {
        CHECK(actual.compactified == expected.compactified);
        check_vector(actual.reference_position, expected.reference_position, comparison_tolerance);
        check_vector(actual.displaced_position, expected.displaced_position, comparison_tolerance);
        check_vector(actual.physical_position, expected.physical_position, comparison_tolerance);
        check_matrix(actual.displacement_jacobian, expected.displacement_jacobian, comparison_tolerance);
        check_matrix(actual.mapping_jacobian, expected.mapping_jacobian, comparison_tolerance);
        check_matrix(actual.inverse_mapping_jacobian, expected.inverse_mapping_jacobian, comparison_tolerance);
        CHECK_THAT(actual.mapping_determinant, WithinAbs(expected.mapping_determinant, comparison_tolerance));
    }

    constexpr double polynomial_tolerance = 2.0e-11;
    constexpr double difference_step      = 2.0e-6;

    struct QuadraticElementFixture {
        mfem::Mesh mesh;
        mfem::H1_FECollection displacement_collection;
        mfem::FiniteElementSpace displacement_space;

        QuadraticElementFixture()
            : mesh(
                  mfem::Mesh::MakeCartesian3D(
                      1,
                      1,
                      1,
                      mfem::Element::HEXAHEDRON,
                      2.0,
                      3.0,
                      4.0
                  )
              ),
              displacement_collection(
                  2,
                  dimension
              ),
              displacement_space(
                  &mesh,
                  &displacement_collection,
                  dimension,
                  mfem::Ordering::byVDIM
              ) {
        }

        [[nodiscard]] const mfem::FiniteElement &GetElement() const {
            return *displacement_space.GetFE(0);
        }
    };

    template <typename Function>
    mfem::Vector make_function_element_dofs(
        const mfem::FiniteElement &element,
        mfem::ElementTransformation &transformation,
        Function &&function,
        const mfem::Ordering::Type ordering
    ) {
        const int dof_count                = element.GetDof();
        const mfem::IntegrationRule &nodes = element.GetNodes();

        REQUIRE(nodes.GetNPoints() == dof_count);

        mfem::Vector element_dofs(dof_count * dimension);
        mfem::Vector reference_position(dimension);
        mfem::Vector value(dimension);

        for (int i = 0; i < dof_count; ++i) {
            transformation.Transform(nodes.IntPoint(i), reference_position);
            function(reference_position, value);

            for (int component = 0; component < dimension; ++component) {
                const int index =
                    ordering == mfem::Ordering::byNODES ? i + component * dof_count : component + i * dimension;
                element_dofs(index) = value(component);
            }
        }

        return element_dofs;
    }

    void evaluate_quadratic_displacement(
        const mfem::Vector &position,
        mfem::Vector &displacement
    ) {
        const double x = position(0);
        const double y = position(1);
        const double z = position(2);

        displacement.SetSize(dimension);
        displacement(0) = 0.01 + 0.010 * x * x + 0.005 * y * z;
        displacement(1) = -0.02 - 0.004 * x * y + 0.006 * z * z;
        displacement(2) = 0.015 + 0.003 * x * z - 0.002 * y * y;
    }

    mfem::DenseMatrix evaluate_quadratic_displacement_gradient(const mfem::Vector &position) {
        const double x = position(0);
        const double y = position(1);
        const double z = position(2);

        mfem::DenseMatrix gradient(dimension);
        gradient(0, 0) = 0.020 * x;
        gradient(0, 1) = 0.005 * z;
        gradient(0, 2) = 0.005 * y;
        gradient(1, 0) = -0.004 * y;
        gradient(1, 1) = -0.004 * x;
        gradient(1, 2) = 0.012 * z;
        gradient(2, 0) = 0.003 * z;
        gradient(2, 1) = -0.004 * y;
        gradient(2, 2) = 0.003 * x;
        return gradient;
    }

    void evaluate_quadratic_direction(
        const mfem::Vector &position,
        mfem::Vector &direction
    ) {
        const double x = position(0);
        const double y = position(1);
        const double z = position(2);

        direction.SetSize(dimension);
        direction(0) = 0.020 * x - 0.010 * y * z;
        direction(1) = -0.015 * y + 0.005 * x * z;
        direction(2) = 0.010 * z + 0.004 * x * y;
    }

    mfem::DenseMatrix evaluate_quadratic_direction_gradient(const mfem::Vector &position) {
        const double x = position(0);
        const double y = position(1);
        const double z = position(2);

        mfem::DenseMatrix gradient(dimension);
        gradient(0, 0) = 0.020;
        gradient(0, 1) = -0.010 * z;
        gradient(0, 2) = -0.010 * y;
        gradient(1, 0) = 0.005 * z;
        gradient(1, 1) = -0.015;
        gradient(1, 2) = 0.005 * x;
        gradient(2, 0) = 0.004 * y;
        gradient(2, 1) = 0.004 * x;
        gradient(2, 2) = 0.010;
        return gradient;
    }

    void check_vector_central_difference(
        const mfem::Vector &plus,
        const mfem::Vector &minus,
        const mfem::Vector &expected,
        const double step,
        const double comparison_tolerance
    ) {
        REQUIRE(plus.Size() == minus.Size());
        REQUIRE(plus.Size() == expected.Size());

        for (int i = 0; i < expected.Size(); ++i) {
            const double finite_difference = (plus(i) - minus(i)) / (2.0 * step);
            CHECK_THAT(finite_difference, WithinAbs(expected(i), comparison_tolerance));
        }
    }

    void check_matrix_central_difference(
        const mfem::DenseMatrix &plus,
        const mfem::DenseMatrix &minus,
        const mfem::DenseMatrix &expected,
        const double step,
        const double comparison_tolerance
    ) {
        REQUIRE(plus.Height() == minus.Height());
        REQUIRE(plus.Width() == minus.Width());
        REQUIRE(plus.Height() == expected.Height());
        REQUIRE(plus.Width() == expected.Width());

        for (int i = 0; i < expected.Height(); ++i) {
            for (int j = 0; j < expected.Width(); ++j) {
                const double finite_difference = (plus(i, j) - minus(i, j)) / (2.0 * step);
                CHECK_THAT(finite_difference, WithinAbs(expected(i, j), comparison_tolerance));
            }
        }
    }

    struct QuadraticMappingData {
        mfem::Vector base_dofs;
        mfem::Vector direction_dofs;
        mfem::Vector plus_dofs;
        mfem::Vector minus_dofs;

        QuadraticMappingData(
            const mfem::FiniteElement &element,
            mfem::ElementTransformation &transformation
        ) {
            base_dofs = make_function_element_dofs(
                element, transformation, evaluate_quadratic_displacement, mfem::Ordering::byVDIM
            );
            direction_dofs = make_function_element_dofs(
                element, transformation, evaluate_quadratic_direction, mfem::Ordering::byVDIM
            );
            plus_dofs  = base_dofs;
            minus_dofs = base_dofs;
            plus_dofs.Add(difference_step, direction_dofs);
            minus_dofs.Add(-difference_step, direction_dofs);
        }
    };

    void check_scalar_relative(
        const double actual,
        const double expected,
        const double relative_tolerance,
        const double absolute_tolerance = 1.0e-11
    ) {
        CHECK_THAT(actual, WithinAbs(expected, absolute_tolerance + relative_tolerance * std::abs(expected)));
    }

    void check_vector_central_difference_relative(
        const mfem::Vector &plus,
        const mfem::Vector &minus,
        const mfem::Vector &expected,
        const double step,
        const double relative_tolerance
    ) {
        REQUIRE(plus.Size() == minus.Size());
        REQUIRE(plus.Size() == expected.Size());

        for (int i = 0; i < expected.Size(); ++i) {
            const double finite_difference = (plus(i) - minus(i)) / (2.0 * step);
            check_scalar_relative(finite_difference, expected(i), relative_tolerance);
        }
    }

    void check_matrix_central_difference_relative(
        const mfem::DenseMatrix &plus,
        const mfem::DenseMatrix &minus,
        const mfem::DenseMatrix &expected,
        const double step,
        const double relative_tolerance
    ) {
        REQUIRE(plus.Height() == minus.Height());
        REQUIRE(plus.Width() == minus.Width());
        REQUIRE(plus.Height() == expected.Height());
        REQUIRE(plus.Width() == expected.Width());

        for (int i = 0; i < expected.Height(); ++i) {
            for (int j = 0; j < expected.Width(); ++j) {
                const double finite_difference = (plus(i, j) - minus(i, j)) / (2.0 * step);
                check_scalar_relative(finite_difference, expected(i, j), relative_tolerance);
            }
        }
    }

    mfem::Vector evaluate_reference_hdiv_field(const mfem::Vector &position) {
        const double x = position(0);
        const double y = position(1);
        const double z = position(2);
        return make_vector(x * x + 0.1 * y, y * y - 0.2 * z, z * z + 0.3 * x);
    }

    double evaluate_reference_hdiv_divergence(const mfem::Vector &position) {
        return 2.0 * (position(0) + position(1) + position(2));
    }

    mfem::Vector matrix_curl(const mfem::DenseMatrix &gradient) {
        return make_vector(
            gradient(2, 1) - gradient(1, 2), gradient(0, 2) - gradient(2, 0), gradient(1, 0) - gradient(0, 1)
        );
    }

    void check_centered_difference(
        const double analytic,
        const double finite_difference,
        const double plus_value,
        const double minus_value,
        const double step,
        const double relative_tolerance = 2.0e-6,
        const double absolute_tolerance = 1.0e-11
    ) {
        const double derivative_scale   = std::max(std::abs(analytic), std::abs(finite_difference));
        const double primal_scale       = std::max(std::abs(plus_value), std::abs(minus_value));
        const double roundoff_tolerance = 8.0 * std::numeric_limits<double>::epsilon() * primal_scale / step;
        const double tolerance = absolute_tolerance + relative_tolerance * derivative_scale + roundoff_tolerance;

        CHECK_THAT(finite_difference, Catch::Matchers::WithinAbs(analytic, tolerance));
    }

    double relative_vector_difference(
        const mfem::Vector &lhs,
        const mfem::Vector &rhs
    ) {
        mfem::Vector difference(lhs);
        difference -= rhs;

        const double scale = std::max({lhs.Norml2(), rhs.Norml2(), 1.0e-12});
        return difference.Norml2() / scale;
    }

    double relative_matrix_difference(
        const mfem::DenseMatrix &lhs,
        const mfem::DenseMatrix &rhs
    ) {
        mfem::DenseMatrix difference(lhs);
        difference -= rhs;

        const double scale = std::max({lhs.FNorm(), rhs.FNorm(), 1.0e-12});
        return difference.FNorm() / scale;
    }
} // namespace

TEST_CASE(
    "Element Displacement Data Preserves MFEM Ordering",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element = fixture.GetElement();
    const int dof_count                = element.GetDof();

    mfem::Vector by_vdim_dofs(dof_count * dimension);
    mfem::Vector by_nodes_dofs(dof_count * dimension);

    for (int i = 0; i < dof_count; ++i) {
        for (int component = 0; component < dimension; ++component) {
            const double value                       = 100.0 * component + i + 1.0;
            by_vdim_dofs(component + i * dimension)  = value;
            by_nodes_dofs(i + component * dof_count) = value;
        }
    }

    const mapping::ElementDisplacementData by_vdim_data(element, by_vdim_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData by_nodes_data(element, by_nodes_dofs, mfem::Ordering::byNODES);

    REQUIRE(&by_vdim_data.GetElement() == &element);
    REQUIRE(&by_nodes_data.GetElement() == &element);
    REQUIRE(by_vdim_data.GetDimension() == dimension);
    REQUIRE(by_nodes_data.GetDimension() == dimension);
    REQUIRE(by_vdim_data.GetDofCount() == dof_count);
    REQUIRE(by_nodes_data.GetDofCount() == dof_count);
    REQUIRE(by_vdim_data.GetOrdering() == mfem::Ordering::byVDIM);
    REQUIRE(by_nodes_data.GetOrdering() == mfem::Ordering::byNODES);

    check_matrix(by_vdim_data.GetDofMatrix(), by_nodes_data.GetDofMatrix(), 0.0);

    for (int i = 0; i < dof_count; ++i) {
        for (int component = 0; component < dimension; ++component) {
            CHECK_THAT(by_vdim_data.GetDofMatrix()(i, component), WithinAbs(100.0 * component + i + 1.0, 0.0));
        }
    }
}

TEST_CASE(
    "Element Displacement Data Rejects Invalid Vector Sizes",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element = fixture.GetElement();
    const int dof_count                = element.GetDof();

    mfem::Vector empty_dofs;
    mfem::Vector incomplete_dofs(dof_count * dimension - 1);
    incomplete_dofs = 0.0;

    CHECK_THROWS_AS(
        mapping::ElementDisplacementData(element, empty_dofs, mfem::Ordering::byVDIM), std::invalid_argument
    );
    CHECK_THROWS_AS(
        mapping::ElementDisplacementData(element, incomplete_dofs, mfem::Ordering::byVDIM), std::invalid_argument
    );
}

TEST_CASE(
    "Domain Mapping Workspace Tracks Its Dimension",
    tags::unit &tags::mapping
) {
    mapping::DomainMapper::Workspace workspace(dimension);

    REQUIRE(workspace.GetDimension() == dimension);

    workspace.SetDimension(2);
    REQUIRE(workspace.GetDimension() == 2);

    workspace.SetDimension(dimension);
    REQUIRE(workspace.GetDimension() == dimension);

    CHECK_THROWS_AS(workspace.SetDimension(0), std::invalid_argument);
    CHECK_THROWS_AS(workspace.SetDimension(-1), std::invalid_argument);
    CHECK_THROWS_AS(mapping::DomainMapper::Workspace(0), std::invalid_argument);
}

TEST_CASE(
    "Stateless Domain Mapper Validates Its Configuration",
    tags::unit &tags::mapping
) {
    const utils::DomainMapperOptions valid_options{.dimension = dimension, .vacuum_element_attribute = 3};
    mapping::DomainMapper mapper(valid_options, make_kelvin_compactification());

    REQUIRE(mapper.GetDimension() == dimension);
    REQUIRE(mapper.GetExteriorMap().GetName() == "KelvinCompactification");

    const utils::DomainMapperOptions invalid_dimension{.dimension = 0, .vacuum_element_attribute = 3};
    const utils::DomainMapperOptions invalid_attribute{.dimension = dimension, .vacuum_element_attribute = 0};

    CHECK_THROWS_AS(mapping::DomainMapper(invalid_dimension, make_kelvin_compactification()), std::invalid_argument);
    CHECK_THROWS_AS(mapping::DomainMapper(invalid_attribute, make_kelvin_compactification()), std::invalid_argument);

    std::unique_ptr<const mapping::compactification::ExteriorDomainMap> null_exterior_map;
    CHECK_THROWS_AS(mapping::DomainMapper(valid_options, std::move(null_exterior_map)), std::invalid_argument);
}

TEST_CASE(
    "Stateless Domain Mapper Preserves Identity Point Geometry",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element = fixture.GetElement();
    const mfem::Vector zero_dofs       = fixture.MakeZeroElementDofs();
    const mapping::ElementDisplacementData displacement(element, zero_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::MappingPointContext context;

    mfem::ElementTransformation *transformation = fixture.mesh.GetElementTransformation(0);
    REQUIRE_FALSE(mapper.IsCompactifiedElement(*transformation));

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 4);
    const mfem::DenseMatrix identity              = make_identity_matrix(dimension);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
        mfem::Vector expected_position(dimension);
        transformation->Transform(integration_point, expected_position);

        REQUIRE(
            mapper.EvaluatePoint(element_data.Get(), *transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(q);
        REQUIRE_FALSE(context.compactified);
        check_vector(context.reference_position, expected_position);
        check_vector(context.displaced_position, expected_position);
        check_vector(context.physical_position, expected_position);
        check_matrix(context.displacement_jacobian, identity);
        check_matrix(context.mapping_jacobian, identity);
        check_matrix(context.inverse_mapping_jacobian, identity);
        CHECK_THAT(context.mapping_determinant, WithinAbs(1.0, tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Preserves Identity Volume Geometry",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element = fixture.GetElement();
    const mfem::Vector zero_dofs       = fixture.MakeZeroElementDofs();
    const mapping::ElementDisplacementData displacement(element, zero_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::VolumeMappingContext context;

    mfem::ElementTransformation *transformation   = fixture.mesh.GetElementTransformation(0);
    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 4);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

        REQUIRE(
            mapper.EvaluateVolume(element_data.Get(), *transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        transformation->SetIntPoint(&integration_point);

        mfem::DenseMatrix expected_inverse(dimension);
        mfem::CalcInverse(transformation->Jacobian(), expected_inverse);

        const double expected_weight = integration_point.weight * transformation->Weight();

        CAPTURE(q);
        REQUIRE_FALSE(context.mapping.compactified);
        check_matrix(context.quadrature.J_inv, expected_inverse);
        CHECK_THAT(context.quadrature.detJ, WithinAbs(1.0, tolerance));
        CHECK_THAT(context.quadrature.weight, WithinAbs(expected_weight, tolerance));
        CHECK(context.quadrature.weight > 0.0);
    }
}

TEST_CASE(
    "Stateless Domain Mapper Preserves Identity Face Geometry",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element = fixture.GetElement();
    const mfem::Vector zero_dofs       = fixture.MakeZeroElementDofs();
    const mapping::ElementDisplacementData displacement(element, zero_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::FaceMappingContext context;

    for (int boundary_element = 0; boundary_element < fixture.mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *transformation = fixture.mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(transformation != nullptr);
        REQUIRE(transformation->Elem1 != nullptr);

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 4);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

            REQUIRE(
                mapper.EvaluateFace(
                    element_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, context
                ) == mapping::MappingStatus::valid
            );

            transformation->SetAllIntPoints(&integration_point);

            mfem::Vector raw_normal(dimension);
            mfem::CalcOrtho(transformation->Jacobian(), raw_normal);

            const double raw_normal_magnitude = raw_normal.Norml2();
            mfem::Vector expected_normal(raw_normal);
            expected_normal /= raw_normal_magnitude;

            const double expected_surface_weight                   = integration_point.weight * raw_normal_magnitude;

            const mfem::IntegrationPoint element_integration_point = transformation->Elem1->GetIntPoint();

            mfem::Vector expected_position(dimension);
            transformation->Elem1->Transform(element_integration_point, expected_position);

            CAPTURE(boundary_element, q);
            REQUIRE_FALSE(context.mapping.compactified);
            check_vector(context.mapping.reference_position, expected_position);
            check_vector(context.mapping.displaced_position, expected_position);
            check_vector(context.mapping.physical_position, expected_position);
            check_vector(context.reference_normal, expected_normal);
            check_vector(context.quadrature.normal, expected_normal);
            CHECK_THAT(context.reference_surface_weight, WithinAbs(expected_surface_weight, tolerance));
            CHECK_THAT(context.physical_surface_weight, WithinAbs(expected_surface_weight, tolerance));
            CHECK_THAT(context.quadrature.ds, WithinAbs(expected_surface_weight, tolerance));
            CHECK_THAT(context.quadrature.v_dot_n_scale, WithinAbs(1.0, tolerance));
        }
    }
}

TEST_CASE(
    "Stateless Domain Mapper Matches Exact Affine Point Mapping",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element            = fixture.GetElement();
    mfem::ElementTransformation *transformation   = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix displacement_gradient = make_affine_displacement_gradient();
    const mfem::DenseMatrix deformation_jacobian  = make_deformation_jacobian(displacement_gradient);
    const mfem::Vector displacement_offset        = make_vector(0.07, -0.04, 0.03);
    const mfem::Vector element_dofs               = make_affine_element_dofs(
        element, *transformation, displacement_gradient, displacement_offset, mfem::Ordering::byVDIM
    );
    const mapping::ElementDisplacementData displacement(element, element_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::MappingPointContext context;

    mfem::DenseMatrix inverse_deformation_jacobian(dimension);
    mfem::CalcInverse(deformation_jacobian, inverse_deformation_jacobian);
    const double deformation_determinant = deformation_jacobian.Det();

    REQUIRE(deformation_determinant > 0.0);

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
        mfem::Vector reference_position(dimension);
        transformation->Transform(integration_point, reference_position);

        const mfem::Vector expected_position =
            evaluate_affine_physical_position(reference_position, displacement_gradient, displacement_offset);

        REQUIRE(
            mapper.EvaluatePoint(element_data.Get(), *transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(q);
        REQUIRE_FALSE(context.compactified);
        check_vector(context.reference_position, reference_position);
        check_vector(context.displaced_position, expected_position);
        check_vector(context.physical_position, expected_position);
        check_matrix(context.displacement_jacobian, deformation_jacobian);
        check_matrix(context.mapping_jacobian, deformation_jacobian);
        check_matrix(context.inverse_mapping_jacobian, inverse_deformation_jacobian);
        CHECK_THAT(context.mapping_determinant, WithinAbs(deformation_determinant, tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Produces Equivalent Results For Both MFEM "
    "Orderings",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element            = fixture.GetElement();
    mfem::ElementTransformation *transformation   = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix displacement_gradient = make_affine_displacement_gradient();
    const mfem::Vector displacement_offset        = make_vector(0.07, -0.04, 0.03);

    const mfem::Vector by_vdim_dofs               = make_affine_element_dofs(
        element, *transformation, displacement_gradient, displacement_offset, mfem::Ordering::byVDIM
    );
    const mfem::Vector by_nodes_dofs = make_affine_element_dofs(
        element, *transformation, displacement_gradient, displacement_offset, mfem::Ordering::byNODES
    );

    const mapping::ElementDisplacementData by_vdim_displacement(element, by_vdim_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData by_nodes_displacement(element, by_nodes_dofs, mfem::Ordering::byNODES);
    const ElementMappingDataOwner by_vdim_data(by_vdim_displacement);
    const ElementMappingDataOwner by_nodes_data(by_nodes_displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    mapping::VolumeMappingContext by_vdim_context;
    mapping::VolumeMappingContext by_nodes_context;

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

        REQUIRE(
            mapper.EvaluateVolume(by_vdim_data.Get(), *transformation, integration_point, workspace, by_vdim_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolume(
                by_nodes_data.Get(), *transformation, integration_point, workspace, by_nodes_context
            ) == mapping::MappingStatus::valid
        );

        CAPTURE(q);
        check_point_context(by_vdim_context.mapping, by_nodes_context.mapping);
        check_matrix(by_vdim_context.quadrature.J_inv, by_nodes_context.quadrature.J_inv);
        CHECK_THAT(by_vdim_context.quadrature.detJ, WithinAbs(by_nodes_context.quadrature.detJ, tolerance));
        CHECK_THAT(by_vdim_context.quadrature.weight, WithinAbs(by_nodes_context.quadrature.weight, tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Composes Affine Volume Jacobians",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element            = fixture.GetElement();
    mfem::ElementTransformation *transformation   = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix displacement_gradient = make_affine_displacement_gradient();
    const mfem::DenseMatrix mapping_jacobian      = make_deformation_jacobian(displacement_gradient);
    const mfem::Vector displacement_offset        = make_vector(0.07, -0.04, 0.03);
    const mfem::Vector element_dofs               = make_affine_element_dofs(
        element, *transformation, displacement_gradient, displacement_offset, mfem::Ordering::byVDIM
    );
    const mapping::ElementDisplacementData displacement(element, element_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::VolumeMappingContext context;

    const double mapping_determinant = mapping_jacobian.Det();
    REQUIRE(mapping_determinant > 0.0);

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
        transformation->SetIntPoint(&integration_point);

        mfem::DenseMatrix full_element_jacobian(dimension);
        mfem::DenseMatrix expected_inverse(dimension);
        mfem::Mult(mapping_jacobian, transformation->Jacobian(), full_element_jacobian);
        mfem::CalcInverse(full_element_jacobian, expected_inverse);

        const double expected_weight = integration_point.weight * transformation->Weight() * mapping_determinant;

        REQUIRE(
            mapper.EvaluateVolume(element_data.Get(), *transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(q);
        check_matrix(context.mapping.mapping_jacobian, mapping_jacobian);
        check_matrix(context.quadrature.J_inv, expected_inverse);
        CHECK_THAT(context.quadrature.detJ, WithinAbs(mapping_determinant, tolerance));
        CHECK_THAT(context.quadrature.weight, WithinAbs(expected_weight, tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Applies Nanson Formula On Affine Faces",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element                  = fixture.GetElement();
    mfem::ElementTransformation *element_transformation = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix displacement_gradient       = make_affine_displacement_gradient();
    const mfem::DenseMatrix mapping_jacobian            = make_deformation_jacobian(displacement_gradient);
    const mfem::Vector displacement_offset              = make_vector(0.07, -0.04, 0.03);
    const mfem::Vector element_dofs                     = make_affine_element_dofs(
        element, *element_transformation, displacement_gradient, displacement_offset, mfem::Ordering::byVDIM
    );
    const mapping::ElementDisplacementData displacement(element, element_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mfem::DenseMatrix inverse_mapping_jacobian(dimension);
    mfem::CalcInverse(mapping_jacobian, inverse_mapping_jacobian);
    const double mapping_determinant = mapping_jacobian.Det();

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::FaceMappingContext context;

    for (int boundary_element = 0; boundary_element < fixture.mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *transformation = fixture.mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(transformation != nullptr);
        REQUIRE(transformation->Elem1 != nullptr);

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
            transformation->SetAllIntPoints(&integration_point);

            mfem::Vector raw_normal(dimension);
            mfem::Vector mapped_normal(dimension);
            mfem::CalcOrtho(transformation->Jacobian(), raw_normal);

            inverse_mapping_jacobian.MultTranspose(raw_normal, mapped_normal);
            mapped_normal *= mapping_determinant;

            const double raw_normal_magnitude    = raw_normal.Norml2();
            const double mapped_normal_magnitude = mapped_normal.Norml2();

            mfem::Vector expected_reference_normal(raw_normal);
            mfem::Vector expected_physical_normal(mapped_normal);
            expected_reference_normal /= raw_normal_magnitude;
            expected_physical_normal /= mapped_normal_magnitude;

            const double expected_reference_weight = integration_point.weight * raw_normal_magnitude;
            const double expected_physical_weight  = integration_point.weight * mapped_normal_magnitude;
            const double expected_normal_scale     = mapped_normal_magnitude / raw_normal_magnitude;

            REQUIRE(
                mapper.EvaluateFace(
                    element_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, context
                ) == mapping::MappingStatus::valid
            );

            CAPTURE(boundary_element, q);
            check_matrix(context.mapping.mapping_jacobian, mapping_jacobian);
            check_vector(context.reference_normal, expected_reference_normal);
            check_vector(context.quadrature.normal, expected_physical_normal);
            CHECK_THAT(context.reference_surface_weight, WithinAbs(expected_reference_weight, tolerance));
            CHECK_THAT(context.physical_surface_weight, WithinAbs(expected_physical_weight, tolerance));
            CHECK_THAT(context.quadrature.ds, WithinAbs(expected_reference_weight, tolerance));
            CHECK_THAT(context.quadrature.v_dot_n_scale, WithinAbs(expected_normal_scale, tolerance));
        }
    }
}

TEST_CASE(
    "Stateless Domain Mapper Has No Cross State Contamination",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element          = fixture.GetElement();
    mfem::ElementTransformation *transformation = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix gradient_a          = make_affine_displacement_gradient();
    mfem::DenseMatrix gradient_b(3);
    gradient_b                  = 0.0;
    gradient_b(0, 0)            = -0.06;
    gradient_b(0, 2)            = 0.03;
    gradient_b(1, 0)            = 0.02;
    gradient_b(1, 1)            = 0.12;
    gradient_b(2, 1)            = -0.04;
    gradient_b(2, 2)            = 0.07;

    const mfem::Vector offset_a = make_vector(0.07, -0.04, 0.03);
    const mfem::Vector offset_b = make_vector(-0.05, 0.08, -0.02);

    const mfem::Vector dofs_a =
        make_affine_element_dofs(element, *transformation, gradient_a, offset_a, mfem::Ordering::byVDIM);
    const mfem::Vector dofs_b =
        make_affine_element_dofs(element, *transformation, gradient_b, offset_b, mfem::Ordering::byVDIM);

    const mapping::ElementDisplacementData displacement_a(element, dofs_a, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData displacement_b(element, dofs_b, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data_a(displacement_a);
    const ElementMappingDataOwner element_data_b(displacement_b);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    const mfem::IntegrationPoint &integration_point = mfem::Geometries.GetCenter(transformation->GetGeometryType());

    mapping::MappingPointContext first_a;
    mapping::MappingPointContext result_b;
    mapping::MappingPointContext second_a;

    REQUIRE(
        mapper.EvaluatePoint(element_data_a.Get(), *transformation, integration_point, workspace, first_a) ==
        mapping::MappingStatus::valid
    );
    REQUIRE(
        mapper.EvaluatePoint(element_data_b.Get(), *transformation, integration_point, workspace, result_b) ==
        mapping::MappingStatus::valid
    );
    REQUIRE(
        mapper.EvaluatePoint(element_data_a.Get(), *transformation, integration_point, workspace, second_a) ==
        mapping::MappingStatus::valid
    );

    check_point_context(first_a, second_a, 0.0);

    mfem::Vector state_difference(result_b.physical_position);
    state_difference -= first_a.physical_position;
    CHECK(state_difference.Norml2() > 1.0e-3);
}

TEST_CASE(
    "Stateless Domain Mapper Reports Invalid Element States",
    tags::unit &tags::mapping
) {
    SingleElementFixture fixture;

    const mfem::FiniteElement &element              = fixture.GetElement();
    mfem::ElementTransformation *transformation     = fixture.mesh.GetElementTransformation(0);
    const mfem::IntegrationPoint &integration_point = mfem::Geometries.GetCenter(transformation->GetGeometryType());

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::MappingPointContext context;

    mfem::Vector non_finite_dofs = fixture.MakeZeroElementDofs();
    non_finite_dofs(0)           = std::numeric_limits<double>::quiet_NaN();
    const mapping::ElementDisplacementData non_finite_displacement(element, non_finite_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner non_finite_data(non_finite_displacement);

    CHECK(
        mapper.EvaluatePoint(non_finite_data.Get(), *transformation, integration_point, workspace, context) ==
        mapping::MappingStatus::non_finite_input
    );

    mfem::DenseMatrix singular_gradient(dimension);
    singular_gradient = 0.0;
    for (int i = 0; i < dimension; ++i)
        singular_gradient(i, i) = -1.0;

    const mfem::Vector zero_offset(dimension);
    const mfem::Vector singular_dofs =
        make_affine_element_dofs(element, *transformation, singular_gradient, zero_offset, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData singular_displacement(element, singular_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner singular_data(singular_displacement);

    CHECK(
        mapper.EvaluatePoint(singular_data.Get(), *transformation, integration_point, workspace, context) ==
        mapping::MappingStatus::non_positive_determinant
    );

    mfem::DenseMatrix inverted_gradient(dimension);
    inverted_gradient = 0.0;
    for (int i = 0; i < dimension; ++i)
        inverted_gradient(i, i) = -2.0;

    const mfem::Vector inverted_dofs =
        make_affine_element_dofs(element, *transformation, inverted_gradient, zero_offset, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData inverted_displacement(element, inverted_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner inverted_data(inverted_displacement);

    CHECK(
        mapper.EvaluatePoint(inverted_data.Get(), *transformation, integration_point, workspace, context) ==
        mapping::MappingStatus::non_positive_determinant
    );

    mapping::DomainMapper::Workspace wrong_workspace(2);
    CHECK_THROWS_AS(
        mapper.EvaluatePoint(singular_data.Get(), *transformation, integration_point, wrong_workspace, context),
        std::invalid_argument
    );

    mfem::Vector two_dimensional_dofs(element.GetDof() * 2);
    two_dimensional_dofs = 0.0;
    const mapping::ElementDisplacementData two_dimensional_displacement(
        element, two_dimensional_dofs, mfem::Ordering::byVDIM
    );
    const ElementMappingDataOwner two_dimensional_data(two_dimensional_displacement);

    CHECK_THROWS_AS(
        mapper.EvaluatePoint(two_dimensional_data.Get(), *transformation, integration_point, workspace, context),
        std::invalid_argument
    );
}

TEST_CASE(
    "Stateless Domain Mapper Matches Exact Quadratic Point Mapping",
    tags::unit &tags::mapping
) {
    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element          = fixture.GetElement();
    mfem::ElementTransformation *transformation = fixture.mesh.GetElementTransformation(0);

    const mfem::Vector element_dofs =
        make_function_element_dofs(element, *transformation, evaluate_quadratic_displacement, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData displacement(element, element_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);
    mapping::MappingPointContext context;

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

        mfem::Vector reference_position(dimension);
        mfem::Vector expected_displacement(dimension);
        transformation->Transform(integration_point, reference_position);
        evaluate_quadratic_displacement(reference_position, expected_displacement);

        mfem::Vector expected_position(reference_position);
        expected_position += expected_displacement;

        const mfem::DenseMatrix displacement_gradient = evaluate_quadratic_displacement_gradient(reference_position);
        mfem::DenseMatrix expected_jacobian           = make_identity_matrix(dimension);
        expected_jacobian.Add(1.0, displacement_gradient);

        mfem::DenseMatrix expected_inverse(dimension);
        mfem::CalcInverse(expected_jacobian, expected_inverse);
        const double expected_determinant = expected_jacobian.Det();

        REQUIRE(expected_determinant > 0.0);
        REQUIRE(
            mapper.EvaluatePoint(element_data.Get(), *transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(q);
        REQUIRE_FALSE(context.compactified);
        check_vector(context.reference_position, reference_position, polynomial_tolerance);
        check_vector(context.displaced_position, expected_position, polynomial_tolerance);
        check_vector(context.physical_position, expected_position, polynomial_tolerance);
        check_matrix(context.displacement_jacobian, expected_jacobian, polynomial_tolerance);
        check_matrix(context.mapping_jacobian, expected_jacobian, polynomial_tolerance);
        check_matrix(context.inverse_mapping_jacobian, expected_inverse, polynomial_tolerance);
        CHECK_THAT(context.mapping_determinant, WithinAbs(expected_determinant, polynomial_tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Point Linearization Matches Centered Differences",
    tags::unit &tags::mapping
) {
    constexpr double linearization_tolerance = 2.0e-9;

    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element          = fixture.GetElement();
    mfem::ElementTransformation *transformation = fixture.mesh.GetElementTransformation(0);
    const QuadraticMappingData mapping_data(element, *transformation);

    const mapping::ElementDisplacementData base_displacement(element, mapping_data.base_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData direction(element, mapping_data.direction_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData plus_displacement(element, mapping_data.plus_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData minus_displacement(element, mapping_data.minus_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner base_data(base_displacement);
    const ElementMappingDataOwner plus_data(plus_displacement);
    const ElementMappingDataOwner minus_data(minus_displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

        mapping::MappingPointContext base_context;
        mapping::MappingPointContext plus_context;
        mapping::MappingPointContext minus_context;
        mapping::MappingPointVariation variation;

        REQUIRE(
            mapper.EvaluatePoint(base_data.Get(), *transformation, integration_point, workspace, base_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluatePointVariation(
                base_data.Get(), direction, *transformation, integration_point, base_context, workspace, variation
            ) == mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluatePoint(plus_data.Get(), *transformation, integration_point, workspace, plus_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluatePoint(minus_data.Get(), *transformation, integration_point, workspace, minus_context) ==
            mapping::MappingStatus::valid
        );

        mfem::Vector reference_position(dimension);
        mfem::Vector expected_direction(dimension);
        transformation->Transform(integration_point, reference_position);
        evaluate_quadratic_direction(reference_position, expected_direction);

        const mfem::DenseMatrix expected_direction_gradient = evaluate_quadratic_direction_gradient(reference_position);

        CAPTURE(q);
        check_vector(variation.displacement_variation, expected_direction, polynomial_tolerance);
        check_vector(variation.physical_position_variation, expected_direction, polynomial_tolerance);
        check_matrix(variation.displacement_jacobian_variation, expected_direction_gradient, polynomial_tolerance);
        check_matrix(variation.mapping_jacobian_variation, expected_direction_gradient, polynomial_tolerance);

        check_vector_central_difference(
            plus_context.physical_position, minus_context.physical_position, variation.physical_position_variation,
            difference_step, linearization_tolerance
        );
        check_matrix_central_difference(
            plus_context.mapping_jacobian, minus_context.mapping_jacobian, variation.mapping_jacobian_variation,
            difference_step, linearization_tolerance
        );
        check_matrix_central_difference(
            plus_context.inverse_mapping_jacobian, minus_context.inverse_mapping_jacobian,
            variation.inverse_mapping_jacobian_variation, difference_step, linearization_tolerance
        );

        const double determinant_finite_difference =
            (plus_context.mapping_determinant - minus_context.mapping_determinant) / (2.0 * difference_step);
        CHECK_THAT(
            determinant_finite_difference, WithinAbs(variation.mapping_determinant_variation, linearization_tolerance)
        );
    }
}

TEST_CASE(
    "Stateless Domain Mapper Volume Linearization Matches Centered Differences",
    tags::unit &tags::mapping
) {
    constexpr double linearization_tolerance = 5.0e-9;

    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element          = fixture.GetElement();
    mfem::ElementTransformation *transformation = fixture.mesh.GetElementTransformation(0);
    const QuadraticMappingData mapping_data(element, *transformation);

    const mapping::ElementDisplacementData base_displacement(element, mapping_data.base_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData direction(element, mapping_data.direction_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData plus_displacement(element, mapping_data.plus_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData minus_displacement(element, mapping_data.minus_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner base_data(base_displacement);
    const ElementMappingDataOwner plus_data(plus_displacement);
    const ElementMappingDataOwner minus_data(minus_displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

    for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

        mapping::VolumeMappingContext base_context;
        mapping::VolumeMappingContext plus_context;
        mapping::VolumeMappingContext minus_context;
        mapping::VolumeMappingVariation variation;

        REQUIRE(
            mapper.EvaluateVolume(base_data.Get(), *transformation, integration_point, workspace, base_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolumeVariation(
                base_data.Get(), direction, *transformation, integration_point, base_context, workspace, variation
            ) == mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolume(plus_data.Get(), *transformation, integration_point, workspace, plus_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolume(minus_data.Get(), *transformation, integration_point, workspace, minus_context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(q);
        check_matrix_central_difference(
            plus_context.quadrature.J_inv, minus_context.quadrature.J_inv, variation.inverse_element_jacobian_variation,
            difference_step, linearization_tolerance
        );

        const double determinant_finite_difference =
            (plus_context.quadrature.detJ - minus_context.quadrature.detJ) / (2.0 * difference_step);
        const double weight_finite_difference =
            (plus_context.quadrature.weight - minus_context.quadrature.weight) / (2.0 * difference_step);

        CHECK_THAT(
            determinant_finite_difference,
            WithinAbs(variation.mapping.mapping_determinant_variation, linearization_tolerance)
        );
        CHECK_THAT(weight_finite_difference, WithinAbs(variation.weight_variation, linearization_tolerance));
    }
}

TEST_CASE(
    "Stateless Domain Mapper Face Linearization Matches Centered Differences",
    tags::unit &tags::mapping
) {
    constexpr double normal_tolerance  = 2.0e-8;
    constexpr double measure_tolerance = 2.0e-8;

    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element                  = fixture.GetElement();
    mfem::ElementTransformation *element_transformation = fixture.mesh.GetElementTransformation(0);
    const QuadraticMappingData mapping_data(element, *element_transformation);

    const mapping::ElementDisplacementData base_displacement(element, mapping_data.base_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData direction(element, mapping_data.direction_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData plus_displacement(element, mapping_data.plus_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData minus_displacement(element, mapping_data.minus_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner base_data(base_displacement);
    const ElementMappingDataOwner plus_data(plus_displacement);
    const ElementMappingDataOwner minus_data(minus_displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    for (int boundary_element = 0; boundary_element < fixture.mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *transformation = fixture.mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(transformation != nullptr);
        REQUIRE(transformation->Elem1 != nullptr);

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 4);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

            mapping::FaceMappingContext base_context;
            mapping::FaceMappingContext plus_context;
            mapping::FaceMappingContext minus_context;
            mapping::FaceMappingVariation variation;

            REQUIRE(
                mapper.EvaluateFace(
                    base_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point, workspace,
                    base_context
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFaceVariation(
                    base_data.Get(), direction, *transformation, mapping::FaceElementSide::element_1, integration_point,
                    base_context, workspace, variation
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFace(
                    plus_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point, workspace,
                    plus_context
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFace(
                    minus_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, minus_context
                ) == mapping::MappingStatus::valid
            );

            CAPTURE(boundary_element, q);
            check_vector_central_difference(
                plus_context.quadrature.normal, minus_context.quadrature.normal, variation.physical_normal_variation,
                difference_step, normal_tolerance
            );

            const double surface_weight_finite_difference =
                (plus_context.physical_surface_weight - minus_context.physical_surface_weight) /
                (2.0 * difference_step);
            const double normal_scale_finite_difference =
                (plus_context.quadrature.v_dot_n_scale - minus_context.quadrature.v_dot_n_scale) /
                (2.0 * difference_step);

            CHECK_THAT(
                surface_weight_finite_difference,
                WithinAbs(variation.physical_surface_weight_variation, measure_tolerance)
            );
            CHECK_THAT(
                normal_scale_finite_difference, WithinAbs(variation.normal_flux_scale_variation, measure_tolerance)
            );
        }
    }
}

TEST_CASE(
    "Stateless Domain Mapper Rejects Invalid Linearization Directions",
    tags::unit &tags::mapping
) {
    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element              = fixture.GetElement();
    mfem::ElementTransformation *transformation     = fixture.mesh.GetElementTransformation(0);
    const mfem::IntegrationPoint &integration_point = mfem::Geometries.GetCenter(transformation->GetGeometryType());
    const QuadraticMappingData mapping_data(element, *transformation);

    const mapping::ElementDisplacementData base_displacement(element, mapping_data.base_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner base_data(base_displacement);

    mfem::Vector non_finite_direction_dofs(mapping_data.direction_dofs);
    non_finite_direction_dofs(0) = std::numeric_limits<double>::quiet_NaN();
    const mapping::ElementDisplacementData non_finite_direction(
        element, non_finite_direction_dofs, mfem::Ordering::byVDIM
    );

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    mapping::MappingPointContext base_context;
    mapping::MappingPointVariation variation;

    REQUIRE(
        mapper.EvaluatePoint(base_data.Get(), *transformation, integration_point, workspace, base_context) ==
        mapping::MappingStatus::valid
    );
    CHECK(
        mapper.EvaluatePointVariation(
            base_data.Get(), non_finite_direction, *transformation, integration_point, base_context, workspace,
            variation
        ) == mapping::MappingStatus::non_finite_input
    );

    SingleElementFixture linear_fixture;
    const mfem::FiniteElement &linear_element = linear_fixture.GetElement();
    const mfem::Vector linear_direction_dofs  = linear_fixture.MakeZeroElementDofs();
    const mapping::ElementDisplacementData incompatible_direction(
        linear_element, linear_direction_dofs, mfem::Ordering::byVDIM
    );

    CHECK_THROWS_AS(
        mapper.EvaluatePointVariation(
            base_data.Get(), incompatible_direction, *transformation, integration_point, base_context, workspace,
            variation
        ),
        std::invalid_argument
    );
}

TEST_CASE(
    "Mapping Field Transforms Satisfy Piola And Gradient Identities",
    tags::unit &tags::mapping
) {
    constexpr double transform_tolerance = 1.0e-12;

    mapping::MappingPointContext context;
    context.mapping_jacobian.SetSize(3);
    context.mapping_jacobian(0, 0) = 1.20;
    context.mapping_jacobian(0, 1) = 0.15;
    context.mapping_jacobian(0, 2) = -0.05;
    context.mapping_jacobian(1, 0) = -0.08;
    context.mapping_jacobian(1, 1) = 0.95;
    context.mapping_jacobian(1, 2) = 0.12;
    context.mapping_jacobian(2, 0) = 0.04;
    context.mapping_jacobian(2, 1) = -0.10;
    context.mapping_jacobian(2, 2) = 1.10;

    context.mapping_determinant    = context.mapping_jacobian.Det();
    REQUIRE(context.mapping_determinant > 0.0);

    context.inverse_mapping_jacobian.SetSize(3);
    mfem::CalcInverse(context.mapping_jacobian, context.inverse_mapping_jacobian);

    const mfem::Vector reference_flux          = make_vector(0.7, -0.4, 1.1);
    const mfem::Vector reference_test_flux     = make_vector(-0.2, 0.9, 0.5);
    const mfem::Vector reference_gradient      = make_vector(0.3, -0.6, 0.8);
    const mfem::Vector reference_test_gradient = make_vector(-0.7, 0.2, 0.4);

    mfem::Vector physical_flux;
    mfem::Vector recovered_flux;
    mfem::Vector physical_test_flux;
    mfem::Vector physical_gradient;
    mfem::Vector recovered_gradient;
    mfem::Vector physical_test_gradient;

    mapping::MapHDivFluxToPhysical(context, reference_flux, physical_flux);
    mapping::MapPhysicalFluxToHDivReference(context, physical_flux, recovered_flux);
    mapping::MapHDivFluxToPhysical(context, reference_test_flux, physical_test_flux);

    mapping::MapReferenceGradientToPhysical(context, reference_gradient, physical_gradient);
    mapping::MapPhysicalGradientToReference(context, physical_gradient, recovered_gradient);
    mapping::MapReferenceGradientToPhysical(context, reference_test_gradient, physical_test_gradient);

    check_vector(recovered_flux, reference_flux, transform_tolerance);
    check_vector(recovered_gradient, reference_gradient, transform_tolerance);

    mfem::DenseMatrix reference_vector_gradient(3);
    reference_vector_gradient(0, 0) = 0.20;
    reference_vector_gradient(0, 1) = -0.10;
    reference_vector_gradient(0, 2) = 0.04;
    reference_vector_gradient(1, 0) = 0.03;
    reference_vector_gradient(1, 1) = 0.15;
    reference_vector_gradient(1, 2) = -0.08;
    reference_vector_gradient(2, 0) = -0.05;
    reference_vector_gradient(2, 1) = 0.02;
    reference_vector_gradient(2, 2) = 0.11;

    mfem::DenseMatrix physical_vector_gradient;
    mfem::DenseMatrix recovered_vector_gradient;

    mapping::MapReferenceVectorGradientToPhysical(context, reference_vector_gradient, physical_vector_gradient);
    mapping::MapPhysicalVectorGradientToReference(context, physical_vector_gradient, recovered_vector_gradient);
    check_matrix(recovered_vector_gradient, reference_vector_gradient, transform_tolerance);

    mfem::DenseMatrix hdiv_mass_tensor;
    mfem::DenseMatrix diffusion_tensor;
    mapping::ComputeHDivMassTensor(context, hdiv_mass_tensor);
    mapping::ComputeScalarDiffusionTensor(context, diffusion_tensor);

    mfem::Vector mass_action(3);
    mfem::Vector diffusion_action(3);
    hdiv_mass_tensor.Mult(reference_test_flux, mass_action);
    diffusion_tensor.Mult(reference_test_gradient, diffusion_action);

    const double physical_hdiv_inner_product  = context.mapping_determinant * (physical_flux * physical_test_flux);
    const double reference_hdiv_inner_product = reference_flux * mass_action;
    const double physical_gradient_inner_product =
        context.mapping_determinant * (physical_gradient * physical_test_gradient);
    const double reference_gradient_inner_product = reference_gradient * diffusion_action;

    CHECK_THAT(physical_hdiv_inner_product, WithinAbs(reference_hdiv_inner_product, transform_tolerance));
    CHECK_THAT(physical_gradient_inner_product, WithinAbs(reference_gradient_inner_product, transform_tolerance));

    const double reference_divergence = 0.73;
    const double physical_divergence  = mapping::MapHDivDivergenceToPhysical(context, reference_divergence);
    CHECK_THAT(physical_divergence, WithinAbs(reference_divergence / context.mapping_determinant, transform_tolerance));
}

TEST_CASE(
    "Mapped Hdiv Flux Preserves Physical Face Flux",
    tags::unit &tags::mapping
) {
    constexpr double flux_tolerance = 2.0e-11;

    SingleElementFixture fixture;

    const mfem::FiniteElement &element                  = fixture.GetElement();
    mfem::ElementTransformation *element_transformation = fixture.mesh.GetElementTransformation(0);

    const mfem::DenseMatrix displacement_gradient       = make_affine_displacement_gradient();
    const mfem::Vector displacement_offset              = make_vector(0.07, -0.04, 0.03);
    const mfem::Vector element_dofs                     = make_affine_element_dofs(
        element, *element_transformation, displacement_gradient, displacement_offset, mfem::Ordering::byVDIM
    );
    const mapping::ElementDisplacementData displacement(element, element_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    const mfem::Vector reference_flux = make_vector(0.7, -0.4, 1.1);

    for (int boundary_element = 0; boundary_element < fixture.mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *transformation = fixture.mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(transformation != nullptr);

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
            mapping::FaceMappingContext context;
            mfem::Vector physical_flux;

            REQUIRE(
                mapper.EvaluateFace(
                    element_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, context
                ) == mapping::MappingStatus::valid
            );

            mapping::MapHDivFluxToPhysical(context.mapping, reference_flux, physical_flux);

            const double reference_integrated_flux =
                (reference_flux * context.reference_normal) * context.reference_surface_weight;
            const double physical_integrated_flux =
                (physical_flux * context.quadrature.normal) * context.physical_surface_weight;

            CAPTURE(boundary_element, q);
            CHECK_THAT(physical_integrated_flux, WithinAbs(reference_integrated_flux, flux_tolerance));
        }
    }
}

TEST_CASE(
    "Stateless Domain Mapper Represents Strong Rotating Star Geometry",
    tags::integration &tags::mapping
) {
    constexpr double r_star              = 1.0;
    constexpr double r_infinity          = 4.0;
    constexpr double transform_tolerance = 2.0e-10;

    stroid::config::MeshConfig mesh_config;
    mesh_config.refinement_levels       = 0;
    mesh_config.order                   = 2;
    mesh_config.include_external_domain = true;
    mesh_config.r_core                  = 0.25;
    mesh_config.r_star                  = r_star;
    mesh_config.r_infinity              = r_infinity;
    mesh_config.flattening              = 0.0;
    mesh_config.optimization_methods    = stroid::config::OptimizationMethods{false, true};

    stroid::StroidMesh stroid_mesh      = stroid::GenerateMesh(mesh_config);
    mfem::Mesh &mesh                    = *stroid_mesh.mesh;
    REQUIRE(stroid_mesh.exterior_coordinate != nullptr);
    REQUIRE(stroid_mesh.exterior_coordinate->space != nullptr);
    REQUIRE(stroid_mesh.exterior_coordinate->values != nullptr);

    mfem::FiniteElementSpace &compactification_space = *stroid_mesh.exterior_coordinate->space;
    mfem::GridFunction &compactification_coordinate  = *stroid_mesh.exterior_coordinate->values;

    mfem::H1_FECollection displacement_collection(3, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, mfem::Ordering::byVDIM);
    mfem::GridFunction displacement(&displacement_space);

    auto rotating_displacement =
        [r_star, r_infinity](const mfem::Vector &reference_position, mfem::Vector &displacement_value) {
            const double x              = reference_position(0);
            const double y              = reference_position(1);
            const double z              = reference_position(2);
            const double radius_squared = x * x + y * y + z * z;
            const double radius         = std::sqrt(radius_squared);

            displacement_value.SetSize(3);
            displacement_value = 0.0;

            if (radius <= 1.0e-14)
                return;

            const double cylindrical_fraction = (x * x + y * y) / radius_squared;
            const double angular_deformation =
                0.20 * cylindrical_fraction + 0.12 * cylindrical_fraction * cylindrical_fraction;

            double radial_extension = 0.0;
            if (radius <= r_star) {
                radial_extension = radius_squared / (r_star * r_star);
            } else {
                radial_extension = std::max(0.0, (r_infinity - radius) / (r_infinity - r_star));
            }

            const double scale    = radial_extension * angular_deformation;
            displacement_value(0) = scale * x;
            displacement_value(1) = scale * y;
            displacement_value(2) = scale * z;
        };

    mfem::VectorFunctionCoefficient displacement_coefficient(dimension, rotating_displacement);
    displacement.ProjectCoefficient(displacement_coefficient);

    std::unique_ptr<const mapping::compactification::ExteriorDomainMap> exterior_map =
        std::make_unique<mapping::compactification::KelvinCompactification>(
            mapping::compactification::options::KelvinCompactificationOptions{
                .r_star_ref = r_star, .r_inf_ref = r_infinity
            }
        );

    mapping::DomainMapper mapper({.dimension = dimension, .vacuum_element_attribute = 3}, std::move(exterior_map));
    mapping::DomainMapper::Workspace workspace(dimension);

    double minimum_mapping_determinant = std::numeric_limits<double>::infinity();
    double maximum_mapping_determinant = 0.0;
    double stellar_volume              = 0.0;
    double moment_x                    = 0.0;
    double moment_y                    = 0.0;
    double moment_z                    = 0.0;

    int stellar_elements               = 0;
    int vacuum_elements                = 0;

    for (int element_id = 0; element_id < mesh.GetNE(); ++element_id) {
        mfem::ElementTransformation *transformation = mesh.GetElementTransformation(element_id);
        const mfem::FiniteElement *element          = displacement_space.GetFE(element_id);

        mfem::Array<int> element_vdofs;
        mfem::Vector element_dofs;
        displacement_space.GetElementVDofs(element_id, element_vdofs);
        displacement.GetSubVector(element_vdofs, element_dofs);

        const mapping::ElementDisplacementData element_displacement =
            mapping::ElementDisplacementDataFromElementVDofs(*element, element_dofs);

        mfem::Array<int> compactification_dof_indices;
        mfem::Vector compactification_dofs;
        compactification_space.GetElementDofs(element_id, compactification_dof_indices);
        compactification_coordinate.GetSubVector(compactification_dof_indices, compactification_dofs);

        const ElementMappingDataOwner element_data(
            element_displacement, *compactification_space.GetFE(element_id), compactification_dofs
        );
        const int quadrature_order = 2 * element->GetOrder() + 6;
        const mfem::IntegrationRule &integration_rule =
            mfem::IntRules.Get(transformation->GetGeometryType(), quadrature_order);

        if (transformation->Attribute == 3) {
            ++vacuum_elements;
        } else {
            ++stellar_elements;
        }

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);
            mapping::VolumeMappingContext context;

            REQUIRE(
                mapper.EvaluateVolume(element_data.Get(), *transformation, integration_point, workspace, context) ==
                mapping::MappingStatus::valid
            );

            minimum_mapping_determinant = std::min(minimum_mapping_determinant, context.mapping.mapping_determinant);
            maximum_mapping_determinant = std::max(maximum_mapping_determinant, context.mapping.mapping_determinant);

            REQUIRE(context.mapping.mapping_determinant > 0.0);
            REQUIRE(context.quadrature.weight > 0.0);

            mfem::Vector reference_flux = make_vector(
                0.4 + context.mapping.reference_position(0), -0.3 + 0.5 * context.mapping.reference_position(1),
                0.7 - 0.2 * context.mapping.reference_position(2)
            );

            mfem::Vector physical_flux;
            mfem::Vector recovered_flux;
            mapping::MapHDivFluxToPhysical(context.mapping, reference_flux, physical_flux);
            mapping::MapPhysicalFluxToHDivReference(context.mapping, physical_flux, recovered_flux);
            check_vector(recovered_flux, reference_flux, transform_tolerance);

            const mfem::Vector reference_gradient = make_vector(0.3, -0.5, 0.8);
            mfem::Vector physical_gradient;
            mfem::Vector recovered_gradient;
            mapping::MapReferenceGradientToPhysical(context.mapping, reference_gradient, physical_gradient);
            mapping::MapPhysicalGradientToReference(context.mapping, physical_gradient, recovered_gradient);
            check_vector(recovered_gradient, reference_gradient, transform_tolerance);

            if (transformation->Attribute == 3) {
                transformation->SetIntPoint(&integration_point);

                mfem::Vector compactification_gradient(dimension);
                const double coordinate = compactification_coordinate.GetValue(element_id, integration_point);
                compactification_coordinate.GetGradient(*transformation, compactification_gradient);

                mapping::compactification::ExteriorMapResult direct_result;
                const mapping::compactification::ExteriorMapInput direct_input{
                    .reference_position                   = context.mapping.reference_position,
                    .displaced_position                   = context.mapping.displaced_position,
                    .displacement_jacobian                = context.mapping.displacement_jacobian,
                    .compactification_coordinate          = coordinate,
                    .compactification_coordinate_gradient = compactification_gradient
                };

                REQUIRE(mapper.GetExteriorMap().Evaluate(direct_input, direct_result) == mapping::MappingStatus::valid);
                check_vector(context.mapping.physical_position, direct_result.physical_position, transform_tolerance);
                check_matrix(context.mapping.mapping_jacobian, direct_result.mapping_jacobian, transform_tolerance);
            } else {
                check_vector(
                    context.mapping.physical_position, context.mapping.displaced_position, transform_tolerance
                );

                const double x      = context.mapping.physical_position(0);
                const double y      = context.mapping.physical_position(1);
                const double z      = context.mapping.physical_position(2);
                const double weight = context.quadrature.weight;

                stellar_volume += weight;
                moment_x += x * x * weight;
                moment_y += y * y * weight;
                moment_z += z * z * weight;
            }
        }
    }

    REQUIRE(stellar_elements > 0);
    REQUIRE(vacuum_elements > 0);
    REQUIRE(stellar_volume > 0.0);
    REQUIRE(std::isfinite(minimum_mapping_determinant));
    REQUIRE(minimum_mapping_determinant > 0.0);

    const double moment_trace = moment_x + moment_y + moment_z;
    const double quadrupole_x = 3.0 * moment_x - moment_trace;
    const double quadrupole_y = 3.0 * moment_y - moment_trace;
    const double quadrupole_z = 3.0 * moment_z - moment_trace;
    const double normalized_quadrupole =
        std::sqrt(quadrupole_x * quadrupole_x + quadrupole_y * quadrupole_y + quadrupole_z * quadrupole_z) /
        moment_trace;
    const double axisymmetry_error = std::abs(moment_x - moment_y) / (0.5 * (moment_x + moment_y));

    INFO("Stellar volume = " << stellar_volume);
    INFO("Minimum mapping determinant = " << minimum_mapping_determinant);
    INFO("Maximum mapping determinant = " << maximum_mapping_determinant);
    INFO("Normalized geometric quadrupole = " << normalized_quadrupole);
    INFO("Axisymmetry error = " << axisymmetry_error);

    CHECK(moment_x > moment_z);
    CHECK(moment_y > moment_z);
    CHECK(normalized_quadrupole > 1.0e-2);
    CHECK(axisymmetry_error < 5.0e-2);
}

TEST_CASE(
    "Kelvin Composed Domain Mapping Linearization Matches Centered Differences",
    tags::unit &tags::mapping
) {
    constexpr double relative_tolerance     = 2.0e-6;
    constexpr double kelvin_difference_step = 2.0e-4;

    mfem::Mesh mesh = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 2.98, 0.02, 0.02);

    for (int vertex_id = 0; vertex_id < mesh.GetNV(); ++vertex_id) {
        double *vertex = mesh.GetVertex(vertex_id);
        vertex[0] += 1.0;
        vertex[1] -= 0.01;
        vertex[2] -= 0.01;
    }

    mesh.GetElement(0)->SetAttribute(3);
    mesh.SetAttributes();

    mfem::H1_FECollection displacement_collection(2, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, mfem::Ordering::byVDIM);

    const mfem::FiniteElement &element          = *displacement_space.GetFE(0);
    mfem::ElementTransformation *transformation = mesh.GetElementTransformation(0);

    const mfem::Vector base_dofs =
        make_function_element_dofs(element, *transformation, evaluate_quadratic_displacement, mfem::Ordering::byVDIM);
    const mfem::Vector direction_dofs =
        make_function_element_dofs(element, *transformation, evaluate_quadratic_direction, mfem::Ordering::byVDIM);

    mfem::Vector plus_dofs(base_dofs);
    mfem::Vector minus_dofs(base_dofs);
    plus_dofs.Add(kelvin_difference_step, direction_dofs);
    minus_dofs.Add(-kelvin_difference_step, direction_dofs);

    const mapping::ElementDisplacementData base_displacement(element, base_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData direction(element, direction_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData plus_displacement(element, plus_dofs, mfem::Ordering::byVDIM);
    const mapping::ElementDisplacementData minus_displacement(element, minus_dofs, mfem::Ordering::byVDIM);

    const mfem::Vector compactification_dofs =
        make_compactification_element_dofs(element, *transformation, [](const mfem::Vector &reference_position) {
            return (reference_position(0) - 1.0) / 3.0;
        });

    const ElementMappingDataOwner base_data(base_displacement, element, compactification_dofs);
    const ElementMappingDataOwner plus_data(plus_displacement, element, compactification_dofs);
    const ElementMappingDataOwner minus_data(minus_displacement, element, compactification_dofs);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    auto vector_central_difference = [](const mfem::Vector &plus_value, const mfem::Vector &minus_value) {
        mfem::Vector difference(plus_value);
        difference -= minus_value;
        difference *= 1.0 / (2.0 * kelvin_difference_step);
        return difference;
    };

    auto matrix_central_difference = [](const mfem::DenseMatrix &plus_value, const mfem::DenseMatrix &minus_value) {
        mfem::DenseMatrix difference(plus_value);
        difference -= minus_value;
        difference *= 1.0 / (2.0 * kelvin_difference_step);
        return difference;
    };

    for (const double xi : std::array{0.0, 0.25, 0.75, 0.95, 0.99}) {
        mfem::IntegrationPoint integration_point;
        integration_point.x      = 3.0 * xi / 2.98;
        integration_point.y      = 0.5;
        integration_point.z      = 0.5;
        integration_point.weight = 0.73;

        mapping::VolumeMappingContext base_context;
        mapping::VolumeMappingContext plus_context;
        mapping::VolumeMappingContext minus_context;
        mapping::VolumeMappingVariation variation;

        REQUIRE(
            mapper.EvaluateVolume(base_data.Get(), *transformation, integration_point, workspace, base_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolumeVariation(
                base_data.Get(), direction, *transformation, integration_point, base_context, workspace, variation
            ) == mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolume(plus_data.Get(), *transformation, integration_point, workspace, plus_context) ==
            mapping::MappingStatus::valid
        );
        REQUIRE(
            mapper.EvaluateVolume(minus_data.Get(), *transformation, integration_point, workspace, minus_context) ==
            mapping::MappingStatus::valid
        );

        CAPTURE(xi);
        REQUIRE(base_context.mapping.compactified);

        const mfem::Vector physical_position_difference =
            vector_central_difference(plus_context.mapping.physical_position, minus_context.mapping.physical_position);
        const mfem::DenseMatrix mapping_jacobian_difference =
            matrix_central_difference(plus_context.mapping.mapping_jacobian, minus_context.mapping.mapping_jacobian);
        const mfem::DenseMatrix inverse_mapping_jacobian_difference = matrix_central_difference(
            plus_context.mapping.inverse_mapping_jacobian, minus_context.mapping.inverse_mapping_jacobian
        );
        const mfem::DenseMatrix inverse_element_jacobian_difference =
            matrix_central_difference(plus_context.quadrature.J_inv, minus_context.quadrature.J_inv);

        CHECK_THAT(
            relative_vector_difference(physical_position_difference, variation.mapping.physical_position_variation),
            Catch::Matchers::WithinAbs(0.0, relative_tolerance)
        );
        CHECK_THAT(
            relative_matrix_difference(mapping_jacobian_difference, variation.mapping.mapping_jacobian_variation),
            Catch::Matchers::WithinAbs(0.0, relative_tolerance)
        );
        CHECK_THAT(
            relative_matrix_difference(
                inverse_mapping_jacobian_difference, variation.mapping.inverse_mapping_jacobian_variation
            ),
            Catch::Matchers::WithinAbs(0.0, relative_tolerance)
        );
        CHECK_THAT(
            relative_matrix_difference(
                inverse_element_jacobian_difference, variation.inverse_element_jacobian_variation
            ),
            Catch::Matchers::WithinAbs(0.0, relative_tolerance)
        );

        const double determinant_difference =
            (plus_context.mapping.mapping_determinant - minus_context.mapping.mapping_determinant) /
            (2.0 * kelvin_difference_step);
        const double weight_difference =
            (plus_context.quadrature.weight - minus_context.quadrature.weight) / (2.0 * kelvin_difference_step);

        check_centered_difference(
            variation.mapping.mapping_determinant_variation, determinant_difference,
            plus_context.mapping.mapping_determinant, minus_context.mapping.mapping_determinant, kelvin_difference_step,
            relative_tolerance
        );
        check_centered_difference(
            variation.weight_variation, weight_difference, plus_context.quadrature.weight,
            minus_context.quadrature.weight, kelvin_difference_step, relative_tolerance
        );
    }

    for (int boundary_element = 0; boundary_element < mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *face_transformation = mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(face_transformation != nullptr);

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(face_transformation->GetGeometryType(), 4);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

            mapping::FaceMappingContext base_context;
            mapping::FaceMappingContext plus_context;
            mapping::FaceMappingContext minus_context;
            mapping::FaceMappingVariation variation;

            REQUIRE(
                mapper.EvaluateFace(
                    base_data.Get(), *face_transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, base_context
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFaceVariation(
                    base_data.Get(), direction, *face_transformation, mapping::FaceElementSide::element_1,
                    integration_point, base_context, workspace, variation
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFace(
                    plus_data.Get(), *face_transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, plus_context
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFace(
                    minus_data.Get(), *face_transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, minus_context
                ) == mapping::MappingStatus::valid
            );

            CAPTURE(boundary_element, q);

            const mfem::Vector normal_difference =
                vector_central_difference(plus_context.quadrature.normal, minus_context.quadrature.normal);

            REQUIRE(normal_difference.Size() == variation.physical_normal_variation.Size());
            for (int i = 0; i < normal_difference.Size(); ++i) {
                check_centered_difference(
                    variation.physical_normal_variation(i), normal_difference(i), plus_context.quadrature.normal(i),
                    minus_context.quadrature.normal(i), kelvin_difference_step, relative_tolerance
                );
            }

            const double surface_weight_difference =
                (plus_context.physical_surface_weight - minus_context.physical_surface_weight) /
                (2.0 * kelvin_difference_step);
            const double normal_scale_difference =
                (plus_context.quadrature.v_dot_n_scale - minus_context.quadrature.v_dot_n_scale) /
                (2.0 * kelvin_difference_step);

            check_centered_difference(
                variation.physical_surface_weight_variation, surface_weight_difference,
                plus_context.physical_surface_weight, minus_context.physical_surface_weight, kelvin_difference_step,
                relative_tolerance
            );
            check_centered_difference(
                variation.normal_flux_scale_variation, normal_scale_difference, plus_context.quadrature.v_dot_n_scale,
                minus_context.quadrature.v_dot_n_scale, kelvin_difference_step, relative_tolerance
            );
        }
    }
}
TEST_CASE(
    "Stateless Domain Mapper Produces Consistent Two Sided Interface Geometry",
    tags::integration &tags::mapping
) {
    constexpr double r_star              = 1.0;
    constexpr double r_infinity          = 4.0;
    constexpr double interface_tolerance = 2.0e-7;

    stroid::config::MeshConfig mesh_config;
    mesh_config.refinement_levels       = 0;
    mesh_config.order                   = 2;
    mesh_config.include_external_domain = true;
    mesh_config.r_core                  = 0.25;
    mesh_config.r_star                  = r_star;
    mesh_config.r_infinity              = r_infinity;
    mesh_config.flattening              = 0.0;
    mesh_config.optimization_methods    = stroid::config::OptimizationMethods{false, true};

    stroid::StroidMesh stroid_mesh      = stroid::GenerateMesh(mesh_config);
    mfem::Mesh &mesh                    = *stroid_mesh.mesh;
    REQUIRE(stroid_mesh.exterior_coordinate != nullptr);
    REQUIRE(stroid_mesh.exterior_coordinate->space != nullptr);
    REQUIRE(stroid_mesh.exterior_coordinate->values != nullptr);

    mfem::FiniteElementSpace &compactification_space = *stroid_mesh.exterior_coordinate->space;
    mfem::GridFunction &compactification_coordinate  = *stroid_mesh.exterior_coordinate->values;

    mfem::H1_FECollection displacement_collection(2, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, mfem::Ordering::byVDIM);

    auto displacement_function = [](const mfem::Vector &position, mfem::Vector &value) {
        value.SetSize(3);
        value(0) = 0.08 * position(0) + 0.02 * position(1);
        value(1) = -0.03 * position(0) - 0.02 * position(1);
        value(2) = 0.04 * position(2);
    };

    auto direction_function = [](const mfem::Vector &position, mfem::Vector &value) {
        value.SetSize(3);
        value(0) = 0.02 * position(0);
        value(1) = -0.01 * position(1) + 0.005 * position(2);
        value(2) = 0.015 * position(2);
    };

    mfem::VectorFunctionCoefficient displacement_coefficient(dimension, displacement_function);
    mfem::VectorFunctionCoefficient direction_coefficient(dimension, direction_function);

    mfem::GridFunction displacement(&displacement_space);
    mfem::GridFunction direction(&displacement_space);
    displacement.ProjectCoefficient(displacement_coefficient);
    direction.ProjectCoefficient(direction_coefficient);

    std::unique_ptr<const mapping::compactification::ExteriorDomainMap> exterior_map =
        std::make_unique<mapping::compactification::KelvinCompactification>(
            mapping::compactification::options::KelvinCompactificationOptions{
                .r_star_ref = r_star, .r_inf_ref = r_infinity
            }
        );

    mapping::DomainMapper mapper({.dimension = dimension, .vacuum_element_attribute = 3}, std::move(exterior_map));
    mapping::DomainMapper::Workspace workspace(dimension);

    int core_envelope_faces  = 0;
    int stellar_vacuum_faces = 0;

    for (int face_id = 0; face_id < mesh.GetNumFaces(); ++face_id) {
        mfem::FaceElementTransformations *transformation = mesh.GetFaceElementTransformations(face_id);
        if (transformation == nullptr || transformation->Elem1 == nullptr || transformation->Elem2 == nullptr)
            continue;

        const int attribute_1 = transformation->Elem1->Attribute;
        const int attribute_2 = transformation->Elem2->Attribute;
        const bool core_envelope_interface =
            (attribute_1 == 1 && attribute_2 == 2) || (attribute_1 == 2 && attribute_2 == 1);
        const bool stellar_vacuum_interface = (attribute_1 == 3) != (attribute_2 == 3);

        if (!core_envelope_interface && !stellar_vacuum_interface)
            continue;

        if (core_envelope_interface)
            ++core_envelope_faces;
        if (stellar_vacuum_interface)
            ++stellar_vacuum_faces;

        const int element_1 = transformation->Elem1->ElementNo;
        const int element_2 = transformation->Elem2->ElementNo;

        mfem::Array<int> vdofs_1;
        mfem::Array<int> vdofs_2;
        mfem::Vector displacement_dofs_1;
        mfem::Vector displacement_dofs_2;
        mfem::Vector direction_dofs_1;
        mfem::Vector direction_dofs_2;
        mfem::Array<int> compactification_dof_indices_1;
        mfem::Array<int> compactification_dof_indices_2;
        mfem::Vector compactification_dofs_1;
        mfem::Vector compactification_dofs_2;

        displacement_space.GetElementVDofs(element_1, vdofs_1);
        displacement_space.GetElementVDofs(element_2, vdofs_2);
        displacement.GetSubVector(vdofs_1, displacement_dofs_1);
        displacement.GetSubVector(vdofs_2, displacement_dofs_2);
        direction.GetSubVector(vdofs_1, direction_dofs_1);
        direction.GetSubVector(vdofs_2, direction_dofs_2);
        compactification_space.GetElementDofs(element_1, compactification_dof_indices_1);
        compactification_space.GetElementDofs(element_2, compactification_dof_indices_2);
        compactification_coordinate.GetSubVector(compactification_dof_indices_1, compactification_dofs_1);
        compactification_coordinate.GetSubVector(compactification_dof_indices_2, compactification_dofs_2);

        const mapping::ElementDisplacementData displacement_1 =
            mapping::ElementDisplacementDataFromElementVDofs(*displacement_space.GetFE(element_1), displacement_dofs_1);
        const mapping::ElementDisplacementData displacement_2 =
            mapping::ElementDisplacementDataFromElementVDofs(*displacement_space.GetFE(element_2), displacement_dofs_2);
        const mapping::ElementDisplacementData direction_1 =
            mapping::ElementDisplacementDataFromElementVDofs(*displacement_space.GetFE(element_1), direction_dofs_1);
        const mapping::ElementDisplacementData direction_2 =
            mapping::ElementDisplacementDataFromElementVDofs(*displacement_space.GetFE(element_2), direction_dofs_2);

        const ElementMappingDataOwner element_data_1(
            displacement_1, *compactification_space.GetFE(element_1), compactification_dofs_1
        );
        const ElementMappingDataOwner element_data_2(
            displacement_2, *compactification_space.GetFE(element_2), compactification_dofs_2
        );

        const mfem::IntegrationRule &integration_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 6);

        for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

            mapping::FaceMappingContext context_1;
            mapping::FaceMappingContext context_2;
            mapping::FaceMappingVariation variation_1;
            mapping::FaceMappingVariation variation_2;

            auto status_1 = mapper.EvaluateFace(
                element_data_1.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                workspace, context_1
            );
            auto status_2 = mapper.EvaluateFace(
                element_data_2.Get(), *transformation, mapping::FaceElementSide::element_2, integration_point,
                workspace, context_2
            );
            INFO("Element 1 ID = " << transformation->Elem1No);
            INFO("Element 2 ID = " << transformation->Elem2No);
            INFO("Element 1 attribute = " << transformation->Elem1->Attribute);
            INFO("Element 2 attribute = " << transformation->Elem2->Attribute);
            INFO("Element 2 status = " << static_cast<int>(status_2));

            mfem::Vector reference_position(dimension);
            transformation->Elem2->Transform(transformation->Elem2->GetIntPoint(), reference_position);
            INFO(
                std::format(
                    "Reference position = <{},{},{}>", reference_position(0), reference_position(1),
                    reference_position(2)
                )
            );
            INFO(std::format("Reference radius = {}", reference_position.Norml2()));
            INFO(std::format("Reference radius minus r_star = {}", reference_position.Norml2() - r_star));
            REQUIRE(status_1 == mapping::MappingStatus::valid);
            REQUIRE(status_2 == mapping::MappingStatus::valid);
            REQUIRE(
                mapper.EvaluateFaceVariation(
                    element_data_1.Get(), direction_1, *transformation, mapping::FaceElementSide::element_1,
                    integration_point, context_1, workspace, variation_1
                ) == mapping::MappingStatus::valid
            );
            REQUIRE(
                mapper.EvaluateFaceVariation(
                    element_data_2.Get(), direction_2, *transformation, mapping::FaceElementSide::element_2,
                    integration_point, context_2, workspace, variation_2
                ) == mapping::MappingStatus::valid
            );

            CAPTURE(face_id, q, attribute_1, attribute_2);
            check_vector(context_1.mapping.physical_position, context_2.mapping.physical_position, interface_tolerance);
            check_scalar_relative(
                context_1.physical_surface_weight, context_2.physical_surface_weight, interface_tolerance
            );

            mfem::Vector normal_sum(context_1.quadrature.normal);
            normal_sum += context_2.quadrature.normal;
            CHECK(normal_sum.Norml2() < interface_tolerance);

            check_vector(
                variation_1.mapping.physical_position_variation, variation_2.mapping.physical_position_variation,
                interface_tolerance
            );
            check_scalar_relative(
                variation_1.physical_surface_weight_variation, variation_2.physical_surface_weight_variation,
                interface_tolerance
            );

            mfem::Vector normal_variation_sum(variation_1.physical_normal_variation);
            normal_variation_sum += variation_2.physical_normal_variation;
            CHECK(normal_variation_sum.Norml2() < interface_tolerance);

            const mfem::Vector physical_flux = make_vector(0.7, -0.4, 0.9);
            mfem::Vector reference_flux_1;
            mfem::Vector reference_flux_2;

            mapping::MapPhysicalFluxToHDivReference(context_1.mapping, physical_flux, reference_flux_1);
            mapping::MapPhysicalFluxToHDivReference(context_2.mapping, physical_flux, reference_flux_2);

            const double flux_1 = (reference_flux_1 * context_1.reference_normal) * context_1.reference_surface_weight;
            const double flux_2 = (reference_flux_2 * context_2.reference_normal) * context_2.reference_surface_weight;

            CHECK_THAT(flux_1 + flux_2, WithinAbs(0.0, interface_tolerance));
        }
    }

    INFO("Core-envelope interface faces = " << core_envelope_faces);
    INFO("Stellar-vacuum interface faces = " << stellar_vacuum_faces);

    REQUIRE(core_envelope_faces > 0);
    REQUIRE(stellar_vacuum_faces > 0);
}

TEST_CASE(
    "Mapped Hdiv Field Satisfies The Divergence Theorem",
    tags::unit &tags::mapping
) {
    constexpr double divergence_tolerance = 2.0e-9;

    QuadraticElementFixture fixture;

    const mfem::FiniteElement &element                  = fixture.GetElement();
    mfem::ElementTransformation *element_transformation = fixture.mesh.GetElementTransformation(0);

    const mfem::Vector displacement_dofs                = make_function_element_dofs(
        element, *element_transformation, evaluate_quadratic_displacement, mfem::Ordering::byVDIM
    );
    const mapping::ElementDisplacementData displacement(element, displacement_dofs, mfem::Ordering::byVDIM);
    const ElementMappingDataOwner element_data(displacement);

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::DomainMapper::Workspace workspace(dimension);

    double reference_divergence_integral     = 0.0;
    double physical_divergence_integral      = 0.0;
    double physical_boundary_flux            = 0.0;

    const mfem::IntegrationRule &volume_rule = mfem::IntRules.Get(element_transformation->GetGeometryType(), 10);

    for (int q = 0; q < volume_rule.GetNPoints(); ++q) {
        const mfem::IntegrationPoint &integration_point = volume_rule.IntPoint(q);
        mapping::VolumeMappingContext context;

        REQUIRE(
            mapper.EvaluateVolume(element_data.Get(), *element_transformation, integration_point, workspace, context) ==
            mapping::MappingStatus::valid
        );

        element_transformation->SetIntPoint(&integration_point);

        const double reference_divergence = evaluate_reference_hdiv_divergence(context.mapping.reference_position);
        const double physical_divergence  = mapping::MapHDivDivergenceToPhysical(context.mapping, reference_divergence);
        const double reference_weight     = integration_point.weight * element_transformation->Weight();

        reference_divergence_integral += reference_divergence * reference_weight;
        physical_divergence_integral += physical_divergence * context.quadrature.weight;
    }

    for (int boundary_element = 0; boundary_element < fixture.mesh.GetNBE(); ++boundary_element) {
        mfem::FaceElementTransformations *transformation = fixture.mesh.GetBdrFaceTransformations(boundary_element);
        REQUIRE(transformation != nullptr);

        const mfem::IntegrationRule &face_rule = mfem::IntRules.Get(transformation->GetGeometryType(), 10);

        for (int q = 0; q < face_rule.GetNPoints(); ++q) {
            const mfem::IntegrationPoint &integration_point = face_rule.IntPoint(q);
            mapping::FaceMappingContext context;

            REQUIRE(
                mapper.EvaluateFace(
                    element_data.Get(), *transformation, mapping::FaceElementSide::element_1, integration_point,
                    workspace, context
                ) == mapping::MappingStatus::valid
            );

            const mfem::Vector reference_flux = evaluate_reference_hdiv_field(context.mapping.reference_position);
            mfem::Vector physical_flux;
            mapping::MapHDivFluxToPhysical(context.mapping, reference_flux, physical_flux);

            physical_boundary_flux += (physical_flux * context.quadrature.normal) * context.physical_surface_weight;
        }
    }

    constexpr double analytic_reference_integral = 216.0;

    INFO("Analytic reference divergence integral = " << analytic_reference_integral);
    INFO("Computed reference divergence integral = " << reference_divergence_integral);
    INFO("Computed physical divergence integral = " << physical_divergence_integral);
    INFO("Computed physical boundary flux = " << physical_boundary_flux);

    CHECK_THAT(reference_divergence_integral, WithinAbs(analytic_reference_integral, divergence_tolerance));
    CHECK_THAT(physical_divergence_integral, WithinAbs(analytic_reference_integral, divergence_tolerance));
    CHECK_THAT(physical_boundary_flux, WithinAbs(analytic_reference_integral, divergence_tolerance));
}

TEST_CASE(
    "Mapped Hcurl Fields Preserve Covariant Piola Identities",
    tags::unit &tags::mapping
) {
    constexpr double curl_tolerance = 2.0e-12;

    mapping::MappingPointContext context;
    context.mapping_jacobian.SetSize(3);
    context.mapping_jacobian(0, 0) = 1.20;
    context.mapping_jacobian(0, 1) = 0.15;
    context.mapping_jacobian(0, 2) = -0.05;
    context.mapping_jacobian(1, 0) = -0.08;
    context.mapping_jacobian(1, 1) = 0.95;
    context.mapping_jacobian(1, 2) = 0.12;
    context.mapping_jacobian(2, 0) = 0.04;
    context.mapping_jacobian(2, 1) = -0.10;
    context.mapping_jacobian(2, 2) = 1.10;

    context.mapping_determinant    = context.mapping_jacobian.Det();
    REQUIRE(context.mapping_determinant > 0.0);

    context.inverse_mapping_jacobian.SetSize(3);
    mfem::CalcInverse(context.mapping_jacobian, context.inverse_mapping_jacobian);

    const mfem::Vector reference_field      = make_vector(0.7, -0.4, 1.1);
    const mfem::Vector reference_test_field = make_vector(-0.2, 0.9, 0.5);

    mfem::DenseMatrix reference_gradient(3);
    reference_gradient(0, 0)          = 0.20;
    reference_gradient(0, 1)          = -0.10;
    reference_gradient(0, 2)          = 0.04;
    reference_gradient(1, 0)          = 0.03;
    reference_gradient(1, 1)          = 0.15;
    reference_gradient(1, 2)          = -0.08;
    reference_gradient(2, 0)          = -0.05;
    reference_gradient(2, 1)          = 0.02;
    reference_gradient(2, 2)          = 0.11;

    const mfem::Vector reference_curl = matrix_curl(reference_gradient);

    mfem::Vector physical_field;
    mfem::Vector recovered_field;
    mfem::Vector physical_test_field;
    mfem::Vector physical_curl;
    mfem::Vector recovered_curl;

    mapping::MapHCurlFieldToPhysical(context, reference_field, physical_field);
    mapping::MapPhysicalFieldToHCurlReference(context, physical_field, recovered_field);
    mapping::MapHCurlFieldToPhysical(context, reference_test_field, physical_test_field);
    mapping::MapHCurlCurlToPhysical(context, reference_curl, physical_curl);
    mapping::MapPhysicalCurlToHCurlReference(context, physical_curl, recovered_curl);

    check_vector(recovered_field, reference_field, curl_tolerance);
    check_vector(recovered_curl, reference_curl, curl_tolerance);

    mfem::DenseMatrix temporary(3);
    mfem::DenseMatrix physical_gradient(3);
    mfem::MultAtB(context.inverse_mapping_jacobian, reference_gradient, temporary);
    mfem::Mult(temporary, context.inverse_mapping_jacobian, physical_gradient);

    const mfem::Vector directly_computed_physical_curl = matrix_curl(physical_gradient);
    check_vector(directly_computed_physical_curl, physical_curl, curl_tolerance);

    mfem::DenseMatrix mass_tensor;
    mfem::DenseMatrix curl_tensor;
    mapping::ComputeHCurlMassTensor(context, mass_tensor);
    mapping::ComputeHCurlCurlTensor(context, curl_tensor);

    mfem::Vector mass_action(3);
    mass_tensor.Mult(reference_test_field, mass_action);

    const double physical_mass_inner_product  = context.mapping_determinant * (physical_field * physical_test_field);
    const double reference_mass_inner_product = reference_field * mass_action;

    CHECK_THAT(physical_mass_inner_product, WithinAbs(reference_mass_inner_product, curl_tolerance));

    const mfem::Vector reference_test_curl = make_vector(-0.3, 0.6, 0.2);
    mfem::Vector physical_test_curl;
    mfem::Vector curl_action(3);

    mapping::MapHCurlCurlToPhysical(context, reference_test_curl, physical_test_curl);
    curl_tensor.Mult(reference_test_curl, curl_action);

    const double physical_curl_inner_product  = context.mapping_determinant * (physical_curl * physical_test_curl);
    const double reference_curl_inner_product = reference_curl * curl_action;

    CHECK_THAT(physical_curl_inner_product, WithinAbs(reference_curl_inner_product, curl_tolerance));
}

TEST_CASE(
    "Element Displacement Data Matches MFEM GridFunction Evaluation",
    tags::unit &tags::mapping
) {
    constexpr int displacement_order    = 2;
    constexpr int quadrature_order      = 6;
    constexpr double value_tolerance    = 5.0e-13;
    constexpr double gradient_tolerance = 2.0e-12;
    constexpr double mapping_tolerance  = 3.0e-12;

    auto check_space_ordering           = [](const mfem::Ordering::Type space_ordering) {
        mfem::Mesh mesh = mfem::Mesh::MakeCartesian3D(2, 1, 1, mfem::Element::HEXAHEDRON, 2.0, 1.5, 1.25);

        mfem::H1_FECollection displacement_collection(displacement_order, dimension);

        mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, space_ordering);

        mfem::GridFunction displacement(&displacement_space);

        auto displacement_function = [](const mfem::Vector &position, mfem::Vector &value) {
            const double x = position(0);
            const double y = position(1);
            const double z = position(2);

            value.SetSize(dimension);

            value(0) = 0.17 + 0.11 * x - 0.07 * y + 0.03 * y * z;

            value(1) = -0.23 + 0.05 * y + 0.09 * z + 0.02 * x * z;

            value(2) = 0.31 - 0.04 * x + 0.08 * z - 0.015 * x * y;
        };

        mfem::VectorFunctionCoefficient displacement_coefficient(dimension, displacement_function);

        displacement.ProjectCoefficient(displacement_coefficient);

        mapping::DomainMapper mapper(
            {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
        );

        mapping::DomainMapper::Workspace workspace(dimension);

        REQUIRE(displacement_space.GetOrdering() == space_ordering);
        REQUIRE(displacement.VectorDim() == dimension);

        for (int element_id = 0; element_id < mesh.GetNE(); ++element_id) {
            mfem::ElementTransformation *transformation = mesh.GetElementTransformation(element_id);

            REQUIRE(transformation != nullptr);

            const mfem::FiniteElement &displacement_element = *displacement_space.GetFE(element_id);

            mfem::Array<int> element_vdofs;

            mfem::DofTransformation *dof_transformation = displacement_space.GetElementVDofs(element_id, element_vdofs);

            mfem::Vector element_displacement;

            displacement.GetSubVector(element_vdofs, element_displacement);

            if (dof_transformation != nullptr) {
                dof_transformation->InvTransformPrimal(element_displacement);
            }

            const mapping::ElementDisplacementData displacement_data =
                mapping::ElementDisplacementDataFromElementVDofs(displacement_element, element_displacement);

            REQUIRE(displacement_data.GetOrdering() == mfem::Ordering::byNODES);

            const ElementMappingDataOwner element_data(displacement_data);

            const mfem::IntegrationRule &integration_rule =
                mfem::IntRules.Get(transformation->GetGeometryType(), quadrature_order);

            mfem::Vector shape(displacement_element.GetDof());

            mfem::DenseMatrix physical_dshape(displacement_element.GetDof(), dimension);

            mfem::Vector computed_value(dimension);
            mfem::Vector expected_value(dimension);

            mfem::DenseMatrix computed_gradient(dimension, dimension);

            mfem::DenseMatrix expected_gradient(dimension, dimension);

            for (int q = 0; q < integration_rule.GetNPoints(); ++q) {
                const mfem::IntegrationPoint &integration_point = integration_rule.IntPoint(q);

                CAPTURE(static_cast<int>(space_ordering), element_id, q);

                transformation->SetIntPoint(&integration_point);

                displacement_element.CalcShape(integration_point, shape);

                displacement_element.CalcPhysDShape(*transformation, physical_dshape);

                displacement_data.GetDofMatrix().MultTranspose(shape, computed_value);

                mfem::MultAtB(displacement_data.GetDofMatrix(), physical_dshape, computed_gradient);

                /*
                 * Use MFEM's native evaluation as the authoritative
                 * interpretation of the GridFunction.
                 */
                transformation->SetIntPoint(&integration_point);

                displacement.GetVectorValue(*transformation, integration_point, expected_value);

                transformation->SetIntPoint(&integration_point);

                displacement.GetVectorGradient(*transformation, expected_gradient);

                check_vector(computed_value, expected_value, value_tolerance);

                check_matrix(computed_gradient, expected_gradient, gradient_tolerance);

                /*
                 * Also exercise the complete stateless-mapper path.
                 * The Cartesian elements are stellar-domain elements,
                 * so the mapper should produce x + u and I + grad(u).
                 */
                mapping::MappingPointContext context;

                const mapping::MappingStatus status =
                    mapper.EvaluatePoint(element_data.Get(), *transformation, integration_point, workspace, context);

                REQUIRE(status == mean_field::mapping::MappingStatus::valid);

                REQUIRE_FALSE(context.compactified);

                mfem::Vector expected_displaced_position(context.reference_position);

                expected_displaced_position += expected_value;

                mfem::DenseMatrix expected_displacement_jacobian(expected_gradient);

                for (int d = 0; d < dimension; ++d) {
                    expected_displacement_jacobian(d, d) += 1.0;
                }

                check_vector(context.displaced_position, expected_displaced_position, mapping_tolerance);

                check_vector(context.physical_position, expected_displaced_position, mapping_tolerance);

                check_matrix(context.displacement_jacobian, expected_displacement_jacobian, mapping_tolerance);

                check_matrix(context.mapping_jacobian, expected_displacement_jacobian, mapping_tolerance);

                const double expected_determinant = expected_displacement_jacobian.Det();

                CHECK_THAT(
                    context.mapping_determinant, Catch::Matchers::WithinAbs(expected_determinant, mapping_tolerance)
                );

                REQUIRE(context.mapping_determinant > 0.0);
            }
        }
    };

    SECTION("Global finite-element-space ordering is byNODES") {
        check_space_ordering(mfem::Ordering::byNODES);
    }

    SECTION("Global finite-element-space ordering is byVDIM") {
        check_space_ordering(mfem::Ordering::byVDIM);
    }
}

TEST_CASE(
    "Grid Function Mapping Evaluator Refreshes A Cached Displacement Element",
    tags::mapping_evaluator_unit
) {
    mfem::Mesh mesh = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 2.0, 3.0, 4.0);

    mfem::H1_FECollection displacement_collection(1, dimension);
    mfem::H1_FECollection compactification_collection(1, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, mfem::Ordering::byVDIM);
    mfem::FiniteElementSpace compactification_space(&mesh, &compactification_collection);

    mfem::GridFunction displacement(&displacement_space);
    mfem::GridFunction compactification_coordinate(&compactification_space);
    displacement                = 0.0;
    compactification_coordinate = 0.0;

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::GridFunctionMappingEvaluator evaluator(mapper, displacement, compactification_coordinate);

    /* Refreshing before the first evaluation is a validated no-op. */
    evaluator.Refresh();

    mfem::ElementTransformation *transformation = mesh.GetElementTransformation(0);
    REQUIRE(transformation != nullptr);

    mfem::IntegrationPoint integration_point;
    integration_point.Set3(0.31, 0.43, 0.57);

    mapping::MappingPointContext initial_context;
    REQUIRE(
        evaluator.EvaluatePoint(*transformation, integration_point, initial_context) == mapping::MappingStatus::valid
    );

    mfem::Vector reference_position(dimension);
    transformation->Transform(integration_point, reference_position);
    check_vector(initial_context.physical_position, reference_position);

    const mfem::Vector displacement_offset = make_vector(0.17, -0.09, 0.045);
    mfem::VectorFunctionCoefficient displacement_coefficient(
        dimension, [&displacement_offset](const mfem::Vector &, mfem::Vector &value) { value = displacement_offset; }
    );
    displacement.ProjectCoefficient(displacement_coefficient);

    /*
     * The same element ID is still cached. Refresh must eagerly rebuild it from
     * the mutated grid function rather than retaining the old element data.
     */
    evaluator.Refresh();

    mapping::MappingPointContext refreshed_context;
    REQUIRE(
        evaluator.EvaluatePoint(*transformation, integration_point, refreshed_context) == mapping::MappingStatus::valid
    );

    mfem::Vector expected_position(reference_position);
    expected_position += displacement_offset;

    check_vector(refreshed_context.physical_position, expected_position);
    check_vector(refreshed_context.displaced_position, expected_position);

    mfem::Vector physical_position;
    evaluator.GetPhysicalPoint(*transformation, integration_point, physical_position);
    check_vector(physical_position, expected_position);
}

TEST_CASE(
    "Grid Function Mapping Evaluator Invalidates A Cached Compactification Element",
    tags::mapping_evaluator_unit
) {
    mfem::Mesh mesh = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 2.0, 3.0, 4.0);
    mesh.GetElement(0)->SetAttribute(3);
    mesh.SetAttributes();

    mfem::H1_FECollection displacement_collection(1, dimension);
    mfem::H1_FECollection compactification_collection(1, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &displacement_collection, dimension, mfem::Ordering::byVDIM);
    mfem::FiniteElementSpace compactification_space(&mesh, &compactification_collection);

    mfem::GridFunction displacement(&displacement_space);
    mfem::GridFunction compactification_coordinate(&compactification_space);
    displacement                = 0.0;
    compactification_coordinate = 0.20;

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );
    mapping::GridFunctionMappingEvaluator evaluator(mapper, displacement, compactification_coordinate);

    mfem::ElementTransformation *transformation = mesh.GetElementTransformation(0);
    REQUIRE(transformation != nullptr);

    mfem::IntegrationPoint integration_point;
    integration_point.Set3(0.29, 0.37, 0.61);

    mapping::MappingPointContext initial_context;
    REQUIRE(
        evaluator.EvaluatePoint(*transformation, integration_point, initial_context) == mapping::MappingStatus::valid
    );
    REQUIRE(initial_context.compactified);

    compactification_coordinate = 0.40;

    /* Lazy invalidation is idempotent and reloads on the next evaluation. */
    evaluator.InvalidateCache();
    evaluator.InvalidateCache();

    mapping::MappingPointContext refreshed_context;
    REQUIRE(
        evaluator.EvaluatePoint(*transformation, integration_point, refreshed_context) == mapping::MappingStatus::valid
    );
    REQUIRE(refreshed_context.compactified);

    constexpr double coordinate           = 0.40;
    constexpr double computational_radius = 1.0 + 3.0 * coordinate;
    constexpr double expected_scale       = 1.0 / (computational_radius * (1.0 - coordinate));

    mfem::Vector expected_position(refreshed_context.reference_position);
    expected_position *= expected_scale;

    check_vector(refreshed_context.physical_position, expected_position);
    CHECK(relative_vector_difference(initial_context.physical_position, refreshed_context.physical_position) > 1.0e-3);
}

TEST_CASE(
    "Grid Function Mapping Evaluator Rejects Invalid Fields And Rebinding",
    tags::mapping_evaluator_unit
) {
    mfem::Mesh mesh       = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 2.0, 3.0, 4.0);
    mfem::Mesh other_mesh = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 2.0, 3.0, 4.0);

    mfem::H1_FECollection collection(1, dimension);
    mfem::FiniteElementSpace displacement_space(&mesh, &collection, dimension, mfem::Ordering::byVDIM);
    mfem::FiniteElementSpace alternate_displacement_space(&mesh, &collection, dimension, mfem::Ordering::byVDIM);
    mfem::FiniteElementSpace scalar_space(&mesh, &collection);
    mfem::FiniteElementSpace other_scalar_space(&other_mesh, &collection);
    mfem::FiniteElementSpace vector_compactification_space(&mesh, &collection, dimension, mfem::Ordering::byVDIM);

    mfem::GridFunction displacement(&displacement_space);
    mfem::GridFunction scalar_displacement(&scalar_space);
    mfem::GridFunction compactification_coordinate(&scalar_space);
    mfem::GridFunction other_compactification_coordinate(&other_scalar_space);
    mfem::GridFunction vector_compactification_coordinate(&vector_compactification_space);
    mfem::GridFunction detached;

    mapping::DomainMapper mapper(
        {.dimension = dimension, .vacuum_element_attribute = 3}, make_kelvin_compactification()
    );

    CHECK_THROWS_AS(
        (mapping::GridFunctionMappingEvaluator(mapper, detached, compactification_coordinate)), std::invalid_argument
    );
    CHECK_THROWS_AS((mapping::GridFunctionMappingEvaluator(mapper, displacement, detached)), std::invalid_argument);
    CHECK_THROWS_AS(
        (mapping::GridFunctionMappingEvaluator(mapper, scalar_displacement, compactification_coordinate)),
        std::invalid_argument
    );
    CHECK_THROWS_AS(
        (mapping::GridFunctionMappingEvaluator(mapper, displacement, vector_compactification_coordinate)),
        std::invalid_argument
    );
    CHECK_THROWS_AS(
        (mapping::GridFunctionMappingEvaluator(mapper, displacement, other_compactification_coordinate)),
        std::invalid_argument
    );

    mapping::GridFunctionMappingEvaluator evaluator(mapper, displacement, compactification_coordinate);

    mfem::ElementTransformation *transformation = mesh.GetElementTransformation(0);
    REQUIRE(transformation != nullptr);

    mfem::IntegrationPoint integration_point;
    integration_point.Set3(0.5, 0.5, 0.5);

    mapping::MappingPointContext context;
    REQUIRE(evaluator.EvaluatePoint(*transformation, integration_point, context) == mapping::MappingStatus::valid);

    displacement.SetSpace(&alternate_displacement_space);

    CHECK_THROWS_AS(evaluator.Refresh(), std::invalid_argument);
    CHECK_THROWS_AS(evaluator.EvaluatePoint(*transformation, integration_point, context), std::invalid_argument);
}