MeanField/experiments/gravity_accuracy_budget.cpp

#include <catch2/catch_test_macros.hpp>

#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <map>
#include <string>

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

import mean_field;
import test_helpers;
import experiment;

using namespace experiment;

struct AccuracyBudgetEnergies {
    double binding{0.0};
    double virial{0.0};
};

struct AccuracyBudgetMetrics {
    double direct_relative_residual{0.0};
    double gradient_relative_error{0.0};
    double gradient_projection_relative_error{0.0};
    double gradient_solution_projection_gap{0.0};
    double potential_relative_error{0.0};
    double potential_projection_relative_error{0.0};
    double potential_solution_projection_gap{0.0};
    double binding_relative_error{0.0};
    double virial_relative_error{0.0};
    double virial_consistency_error{0.0};
};

static double global_norm(
    const mfem::Vector &vector,
    MPI_Comm communicator
) {
    const double local_norm_squared = vector * vector;
    double global_norm_squared      = 0.0;
    MPI_Allreduce(&local_norm_squared, &global_norm_squared, 1, MPI_DOUBLE, MPI_SUM, communicator);
    return std::sqrt(global_norm_squared);
}

static double global_dot(
    const mfem::Vector &left,
    const mfem::Vector &right,
    MPI_Comm communicator
) {
    const double local_dot    = left * right;
    double global_dot_product = 0.0;
    MPI_Allreduce(&local_dot, &global_dot_product, 1, MPI_DOUBLE, MPI_SUM, communicator);
    return global_dot_product;
}

static void zero_vacuum_density(
    const mean_field::fem::FEM &fem,
    mfem::GridFunction &density
) {
    using DomainSchema = mean_field::utils::domain::CoreEnvelopeVacuumDomainSchema;

    const mean_field::field::FieldDofMap density_map =
        mean_field::field::make_field_dof_map<mean_field::field::Density, DomainSchema>(*fem.densityFes);

    mfem::Vector density_true;
    density.GetTrueDofs(density_true);

    const mfem::Vector supported_density = density_map.gather(density_true);
    density_map.scatter(supported_density, density_true);
    density.SetFromTrueDofs(density_true);
}

static int diagnostic_quadrature_order(const mean_field::fem::FEM &fem) {
    return 2 * std::max(fem.gravityPotentialFes->GetMaxElementOrder(), fem.gravityFluxFes->GetMaxElementOrder()) + 8;
}

static mfem::Vector assemble_monopole_projection_rhs(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &displacement,
    const double mass,
    const double stellar_radius
) {
    *fem.displacement = displacement;

    mfem::Vector local_rhs(fem.gravityFluxFes->GetVSize());
    local_rhs                  = 0.0;

    const int vacuum_attribute = field_dof_test_utils::vacuum_material_attribute;
    const int quadrature_order = diagnostic_quadrature_order(fem);
    mean_field::mapping::GridFunctionMappingEvaluator mapping_evaluator(
        *fem.domainMapperStateless, *fem.displacement, *fem.compactificationCoordinate
    );

    for (int element_id = 0; element_id < fem.mesh->GetNE(); ++element_id) {
        const mfem::FiniteElement &gravity_element  = *fem.gravityFluxFes->GetFE(element_id);
        mfem::ElementTransformation *transformation = fem.mesh->GetElementTransformation(element_id);

        mfem::Array<int> gravity_dofs;
        mfem::DofTransformation *gravity_transform = fem.gravityFluxFes->GetElementVDofs(element_id, gravity_dofs);

        const int dof_count                        = gravity_element.GetDof();
        const int dimension                        = transformation->GetSpaceDim();
        mfem::Vector element_rhs(dof_count);
        mfem::Vector physical_position(dimension);
        mfem::Vector analytic_field(dimension);
        mfem::Vector pulled_field(dimension);
        mfem::DenseMatrix vector_shape(dof_count, dimension);
        element_rhs                       = 0.0;

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

        for (int quadrature_point_id = 0; quadrature_point_id < rule.GetNPoints(); ++quadrature_point_id) {
            const mfem::IntegrationPoint &point = rule.IntPoint(quadrature_point_id);
            mean_field::mapping::MappingPointContext mapping_context;
            MFEM_VERIFY(
                mapping_evaluator.EvaluatePoint(*transformation, point, mapping_context) ==
                    mean_field::mapping::MappingStatus::valid,
                "Invalid mapping in monopole projection RHS."
            );
            physical_position   = mapping_context.physical_position;

            const double radius = physical_position.Norml2();
            MFEM_VERIFY(std::isfinite(radius) && radius > 0.0, "Invalid radius in monopole projection RHS.");

            analytic_field = physical_position;
            if (transformation->Attribute == vacuum_attribute) {
                analytic_field *= mean_field::utils::G * mass / (radius * radius * radius);
            } else {
                analytic_field *= mean_field::utils::G * mass / (stellar_radius * stellar_radius * stellar_radius);
            }

            mapping_context.mapping_jacobian.MultTranspose(analytic_field, pulled_field);

            transformation->SetIntPoint(&point);
            gravity_element.CalcVShape(*transformation, vector_shape);
            const double reference_weight = point.weight * transformation->Weight();

            for (int dof = 0; dof < dof_count; ++dof) {
                for (int component = 0; component < dimension; ++component) {
                    element_rhs(dof) += reference_weight * vector_shape(dof, component) * pulled_field(component);
                }
            }
        }

        if (gravity_transform != nullptr) {
            gravity_transform->TransformDual(element_rhs);
        }
        local_rhs.AddElementVector(gravity_dofs, element_rhs);
    }

    mfem::Vector true_rhs(fem.gravityFluxFes->GetTrueVSize());
    true_rhs                           = 0.0;
    const mfem::Operator *prolongation = fem.gravityFluxFes->GetProlongationMatrix();
    if (prolongation != nullptr) {
        prolongation->MultTranspose(local_rhs, true_rhs);
    } else {
        true_rhs = local_rhs;
    }

    return true_rhs;
}

static mfem::Vector project_monopole_gradient(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &displacement,
    const double mass,
    const double stellar_radius
) {
    mfem::Vector displacement_true;
    displacement.GetTrueDofs(displacement_true);

    const mfem::Vector projection_rhs_true = assemble_monopole_projection_rhs(fem, displacement, mass, stellar_radius);

    mean_field::operators::PreparedMappedHDivMassOperator mass_operator(fem, *fem.domainMapperStateless);
    mass_operator.Prepare(mass_operator.GetDisplacementMap().gather(displacement_true));

    const mfem::Vector projection_rhs = mass_operator.GetFluxMap().gather(projection_rhs_true);

    mfem::CGSolver solver(fem.gravityFluxFes->GetComm());
    solver.SetOperator(mass_operator);
    solver.SetRelTol(1.0e-11);
    solver.SetAbsTol(1.0e-13);
    solver.SetMaxIter(4000);
    solver.SetPrintLevel(0);

    mfem::Vector projected_gradient_reduced(mass_operator.GetFluxMap().reduced_size());
    projected_gradient_reduced = 0.0;
    solver.Mult(projection_rhs, projected_gradient_reduced);

    mfem::Vector residual;
    mass_operator.Mult(projected_gradient_reduced, residual);
    residual -= projection_rhs;

    const double relative_residual =
        global_norm(residual, fem.gravityFluxFes->GetComm()) /
        std::max(global_norm(projection_rhs, fem.gravityFluxFes->GetComm()), std::numeric_limits<double>::epsilon());

    REQUIRE(std::isfinite(relative_residual));
    REQUIRE(relative_residual < 1.0e-8);
    return mass_operator.GetFluxMap().scatter(projected_gradient_reduced);
}

static double mapped_hdiv_relative_gap(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &displacement,
    const mfem::Vector &calculated,
    const mfem::Vector &reference
) {
    mfem::Vector displacement_true;
    displacement.GetTrueDofs(displacement_true);

    mean_field::operators::PreparedMappedHDivMassOperator mass_operator(fem, *fem.domainMapperStateless);
    mass_operator.Prepare(mass_operator.GetDisplacementMap().gather(displacement_true));

    mfem::Vector difference(calculated);
    difference -= reference;
    mfem::Vector difference_action;
    mfem::Vector reference_action;
    const mfem::Vector reduced_difference = mass_operator.GetFluxMap().gather(difference);
    const mfem::Vector reduced_reference  = mass_operator.GetFluxMap().gather(reference);
    mass_operator.Mult(reduced_difference, difference_action);
    mass_operator.Mult(reduced_reference, reference_action);

    const double difference_energy = global_dot(reduced_difference, difference_action, fem.gravityFluxFes->GetComm());
    const double reference_energy  = global_dot(reduced_reference, reference_action, fem.gravityFluxFes->GetComm());
    MFEM_VERIFY(reference_energy > 0.0, "Projected monopole field has zero mapped H(div) norm.");

    return std::sqrt(std::max(0.0, difference_energy) / reference_energy);
}

static AccuracyBudgetEnergies measure_stellar_energies(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &density,
    const mean_field::physics::GravitySolution &solution
) {
    const int vacuum_attribute = field_dof_test_utils::vacuum_material_attribute;
    const int quadrature_order = diagnostic_quadrature_order(fem);
    mean_field::mapping::GridFunctionMappingEvaluator mapping_evaluator(
        *fem.domainMapperStateless, *fem.displacement, *fem.compactificationCoordinate
    );
    double local_binding = 0.0;
    double local_virial  = 0.0;

    mfem::Vector physical_position(3);
    mfem::Vector reference_field(3);
    mfem::Vector physical_field(3);

    for (int element_id = 0; element_id < fem.mesh->GetNE(); ++element_id) {
        mfem::ElementTransformation *transformation = fem.mesh->GetElementTransformation(element_id);
        if (transformation->Attribute == vacuum_attribute) {
            continue;
        }

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

        for (int quadrature_point_id = 0; quadrature_point_id < rule.GetNPoints(); ++quadrature_point_id) {
            const mfem::IntegrationPoint &point = rule.IntPoint(quadrature_point_id);
            transformation->SetIntPoint(&point);

            mean_field::mapping::MappingPointContext mapping_context;
            MFEM_VERIFY(
                mapping_evaluator.EvaluatePoint(*transformation, point, mapping_context) ==
                    mean_field::mapping::MappingStatus::valid,
                "Invalid mapping in energy diagnostic."
            );
            physical_position                         = mapping_context.physical_position;
            const mfem::DenseMatrix &mapping_jacobian = mapping_context.mapping_jacobian;
            const double mapping_determinant          = mapping_context.mapping_determinant;
            MFEM_VERIFY(mapping_determinant > 0.0, "Non-positive mapping determinant in energy diagnostic.");

            solution.gradPhi.GetVectorValue(element_id, point, reference_field);
            mapping_jacobian.Mult(reference_field, physical_field);
            physical_field /= mapping_determinant;

            const double weight = point.weight * transformation->Weight() * mapping_determinant;
            const double rho    = density.GetValue(element_id, point);
            const double phi    = solution.phi.GetValue(element_id, point);
            local_binding += 0.5 * rho * phi * weight;
            local_virial -= rho * (physical_position * physical_field) * weight;
        }
    }

    AccuracyBudgetEnergies energies;
    MPI_Allreduce(&local_binding, &energies.binding, 1, MPI_DOUBLE, MPI_SUM, fem.densityFes->GetComm());
    MPI_Allreduce(&local_virial, &energies.virial, 1, MPI_DOUBLE, MPI_SUM, fem.densityFes->GetComm());
    return energies;
}

static double reduced_gravity_relative_residual(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &density,
    const mfem::GridFunction &displacement,
    const mean_field::physics::GravitySolution &solution
) {
    using GravityFieldForm        = mean_field::utils::blocks::gravity_field_form;

    constexpr auto gradient_block = mean_field::utils::blocks::get_residual_block<GravityFieldForm>(
        mean_field::utils::blocks::gravity_field.gradient_term
    );
    constexpr auto poisson_block = mean_field::utils::blocks::get_residual_block<GravityFieldForm>(
        mean_field::utils::blocks::gravity_field.poisson_term
    );

    using DomainSchema = mean_field::utils::domain::CoreEnvelopeVacuumDomainSchema;
    const mean_field::field::FieldDofMap density_map =
        mean_field::field::make_field_dof_map<mean_field::field::Density, DomainSchema>(*fem.densityFes);
    const mean_field::field::FieldDofMap displacement_map =
        mean_field::field::make_field_dof_map<mean_field::field::Displacement, DomainSchema>(*fem.displacementFes);
    const mean_field::field::FieldDofMap gravity_flux_map =
        mean_field::field::make_field_dof_map<mean_field::field::Gravity, DomainSchema>(*fem.gravityFluxFes);
    const mean_field::field::FieldDofMap gravity_potential_map =
        mean_field::field::make_field_dof_map<mean_field::field::Gravity, DomainSchema>(*fem.gravityPotentialFes);

    const std::array<int, GravityFieldForm::value_block_count> value_sizes{
        density_map.reduced_size(), displacement_map.reduced_size(), gravity_flux_map.reduced_size(),
        gravity_potential_map.reduced_size()
    };
    const std::array<int, GravityFieldForm::residual_block_count> residual_sizes{
        gravity_flux_map.reduced_size(), gravity_potential_map.reduced_size()
    };
    const mean_field::utils::blocks::form_layout<GravityFieldForm> layout(value_sizes, residual_sizes);

    mfem::Vector density_true;
    mfem::Vector displacement_true;
    mfem::Vector gradient_true;
    mfem::Vector potential_true;
    density.GetTrueDofs(density_true);
    displacement.GetTrueDofs(displacement_true);
    solution.gradPhi.GetTrueDofs(gradient_true);
    solution.phi.GetTrueDofs(potential_true);

    mean_field::operators::context::gravity_field::GravityFieldLinearizationContext linearization_context(
        fem, *fem.domainMapperStateless
    );
    mean_field::operators::GravityFieldJacobianOperator jacobian(
        fem, *fem.domainMapperStateless, linearization_context, layout.value_offsets(), layout.residual_offsets()
    );
    mean_field::operators::GravityFieldOperator field_operator(
        fem, *fem.domainMapperStateless, linearization_context, layout.value_offsets(), jacobian
    );
    mean_field::operators::context::gravity_field::GravityFieldGeometryContext geometry_context(
        fem, *fem.domainMapperStateless
    );
    mean_field::operators::ReducedGravityFieldOperator reduced_operator(
        field_operator, geometry_context, displacement_map.gather(displacement_true)
    );

    mfem::Vector right_hand_side;
    reduced_operator.BuildRightHandSide(density_map.gather(density_true), right_hand_side);

    mfem::BlockVector state(layout.residual_offsets());
    state                          = 0.0;
    state.GetBlock(gradient_block) = gravity_flux_map.gather(gradient_true);
    state.GetBlock(poisson_block)  = gravity_potential_map.gather(potential_true);

    mfem::Vector residual;
    reduced_operator.Mult(state, residual);
    residual -= right_hand_side;

    return global_norm(residual, fem.mesh->GetComm()) /
           std::max(global_norm(right_hand_side, fem.mesh->GetComm()), std::numeric_limits<double>::epsilon());
}

static AccuracyBudgetMetrics measure_monopole_accuracy(
    mean_field::fem::FEM &fem,
    const mfem::GridFunction &density,
    const mfem::GridFunction &displacement,
    const mean_field::physics::GravitySolution &solution,
    const mfem::ParGridFunction &projected_potential,
    const mfem::Vector &projected_gradient,
    const double mass,
    const double stellar_radius
) {
    mfem::Vector solution_gradient;
    solution.gradPhi.GetTrueDofs(solution_gradient);

    mfem::Vector solution_potential;
    mfem::Vector projection_potential;
    solution.phi.GetTrueDofs(solution_potential);
    projected_potential.GetTrueDofs(projection_potential);

    mfem::ParGridFunction projected_gradient_grid_function(fem.gravityFluxFes.get());
    projected_gradient_grid_function.SetFromTrueDofs(projected_gradient);

    double local_solution_gradient_error    = 0.0;
    double local_projection_gradient_error  = 0.0;
    double local_gradient_norm              = 0.0;
    double local_solution_potential_error   = 0.0;
    double local_projection_potential_error = 0.0;
    double local_potential_norm             = 0.0;

    const int vacuum_attribute              = field_dof_test_utils::vacuum_material_attribute;
    const int quadrature_order              = diagnostic_quadrature_order(fem);
    mean_field::mapping::GridFunctionMappingEvaluator mapping_evaluator(
        *fem.domainMapperStateless, *fem.displacement, *fem.compactificationCoordinate
    );
    mfem::Vector physical_position(3);
    mfem::Vector analytic_gradient(3);
    mfem::Vector solution_reference_gradient(3);
    mfem::Vector projection_reference_gradient(3);
    mfem::Vector solution_physical_gradient(3);
    mfem::Vector projection_physical_gradient(3);

    for (int element_id = 0; element_id < fem.mesh->GetNE(); ++element_id) {
        mfem::ElementTransformation *transformation = fem.mesh->GetElementTransformation(element_id);
        const mfem::IntegrationRule &rule = mfem::IntRules.Get(transformation->GetGeometryType(), quadrature_order);

        for (int quadrature_point_id = 0; quadrature_point_id < rule.GetNPoints(); ++quadrature_point_id) {
            const mfem::IntegrationPoint &point = rule.IntPoint(quadrature_point_id);
            transformation->SetIntPoint(&point);
            mean_field::mapping::MappingPointContext mapping_context;
            MFEM_VERIFY(
                mapping_evaluator.EvaluatePoint(*transformation, point, mapping_context) ==
                    mean_field::mapping::MappingStatus::valid,
                "Invalid mapping in accuracy diagnostic."
            );
            physical_position                         = mapping_context.physical_position;
            const mfem::DenseMatrix &mapping_jacobian = mapping_context.mapping_jacobian;
            const double mapping_determinant          = mapping_context.mapping_determinant;
            MFEM_VERIFY(mapping_determinant > 0.0, "Non-positive mapping determinant in accuracy diagnostic.");

            const double radius = physical_position.Norml2();
            MFEM_VERIFY(std::isfinite(radius) && radius > 0.0, "Invalid radius in monopole diagnostic.");

            analytic_gradient         = physical_position;
            double analytic_potential = 0.0;
            if (transformation->Attribute == vacuum_attribute) {
                analytic_gradient *= mean_field::utils::G * mass / (radius * radius * radius);
                analytic_potential = -mean_field::utils::G * mass / radius;
            } else {
                analytic_gradient *= mean_field::utils::G * mass / (stellar_radius * stellar_radius * stellar_radius);
                analytic_potential = -mean_field::utils::G * mass *
                                     (3.0 * stellar_radius * stellar_radius - radius * radius) /
                                     (2.0 * stellar_radius * stellar_radius * stellar_radius);
            }

            solution.gradPhi.GetVectorValue(element_id, point, solution_reference_gradient);
            mapping_jacobian.Mult(solution_reference_gradient, solution_physical_gradient);
            solution_physical_gradient /= mapping_determinant;

            projected_gradient_grid_function.GetVectorValue(element_id, point, projection_reference_gradient);
            mapping_jacobian.Mult(projection_reference_gradient, projection_physical_gradient);
            projection_physical_gradient /= mapping_determinant;

            const double solution_potential_value   = solution.phi.GetValue(element_id, point);
            const double projection_potential_value = projected_potential.GetValue(element_id, point);
            const double weight                     = point.weight * transformation->Weight() * mapping_determinant;

            solution_physical_gradient -= analytic_gradient;
            projection_physical_gradient -= analytic_gradient;
            local_solution_gradient_error += weight * (solution_physical_gradient * solution_physical_gradient);
            local_projection_gradient_error += weight * (projection_physical_gradient * projection_physical_gradient);
            local_gradient_norm += weight * (analytic_gradient * analytic_gradient);
            local_solution_potential_error += weight * (solution_potential_value - analytic_potential) *
                                              (solution_potential_value - analytic_potential);
            local_projection_potential_error += weight * (projection_potential_value - analytic_potential) *
                                                (projection_potential_value - analytic_potential);
            local_potential_norm += weight * analytic_potential * analytic_potential;
        }
    }

    const std::array<double, 6> local_values{
        local_solution_gradient_error,  local_projection_gradient_error,  local_gradient_norm,
        local_solution_potential_error, local_projection_potential_error, local_potential_norm
    };
    std::array<double, 6> global_values{};
    MPI_Allreduce(
        local_values.data(), global_values.data(), static_cast<int>(local_values.size()), MPI_DOUBLE, MPI_SUM,
        fem.mesh->GetComm()
    );

    const AccuracyBudgetEnergies energies = measure_stellar_energies(fem, density, solution);
    const double analytic_energy          = -3.0 * mean_field::utils::G * mass * mass / (5.0 * stellar_radius);

    REQUIRE(global_values[2] > 0.0);
    REQUIRE(global_values[5] > 0.0);

    AccuracyBudgetMetrics metrics;
    metrics.direct_relative_residual = reduced_gravity_relative_residual(fem, density, displacement, solution);
    metrics.gradient_relative_error  = std::sqrt(global_values[0] / global_values[2]);
    metrics.gradient_projection_relative_error = std::sqrt(global_values[1] / global_values[2]);
    metrics.gradient_solution_projection_gap =
        mapped_hdiv_relative_gap(fem, displacement, solution_gradient, projected_gradient);
    metrics.potential_relative_error            = std::sqrt(global_values[3] / global_values[5]);
    metrics.potential_projection_relative_error = std::sqrt(global_values[4] / global_values[5]);
    mfem::Vector potential_difference(solution_potential);
    potential_difference -= projection_potential;
    const double projection_potential_norm = global_norm(projection_potential, fem.gravityPotentialFes->GetComm());
    REQUIRE(projection_potential_norm > 0.0);
    metrics.potential_solution_projection_gap =
        global_norm(potential_difference, fem.gravityPotentialFes->GetComm()) / projection_potential_norm;
    metrics.binding_relative_error   = std::abs(energies.binding - analytic_energy) / std::abs(analytic_energy);
    metrics.virial_relative_error    = std::abs(energies.virial - analytic_energy) / std::abs(analytic_energy);
    metrics.virial_consistency_error = std::abs(energies.binding - energies.virial) /
                                       std::max(std::abs(energies.binding), std::numeric_limits<double>::epsilon());
    return metrics;
}

static void run_monopole_case(
    const std::string &sweep_name,
    const std::string &case_name,
    mean_field::utils::Args args,
    const double solver_tolerance,
    const int quadrature_boost
) {
    args.p.rtol                  = solver_tolerance;
    args.p.atol                  = std::min(args.p.atol, solver_tolerance * 1.0e-2);
    args.p.max_iters             = std::max(args.p.max_iters, 2000);
    args.quadrature.global_boost = quadrature_boost;

    mean_field::fem::FEM fem     = mean_field::fem::setup_fem(args.mesh_file, args, 0);
    REQUIRE(fem.domainMapperStateless != nullptr);

    const double stellar_radius = mean_field::utils::RADIUS;
    const double mass           = mean_field::utils::MASS;
    const double density_value  = mass / ((4.0 / 3.0) * M_PI * stellar_radius * stellar_radius * stellar_radius);

    mfem::ParGridFunction displacement(fem.displacementFes.get());
    displacement      = 0.0;
    *fem.displacement = 0.0;
    mfem::GridFunction density(fem.densityFes.get());
    density = density_value;
    zero_vacuum_density(fem, density);
    mean_field::analysis::conserve_mass(fem, density, mass);
    fem.com = mean_field::analysis::get_com(fem, density);
    fem.Q   = mean_field::physics::compute_quadrupole_moment_tensor(fem, density, fem.com);

    const mean_field::physics::GravitySolution solution =
        mean_field::physics::solve_gravity_field(fem, args, density, displacement);

    auto analytic_potential = [mass, stellar_radius](const mfem::Vector &position) {
        const double radius = position.Norml2();
        if (radius >= stellar_radius) {
            return -mean_field::utils::G * mass / radius;
        }
        return -mean_field::utils::G * mass * (3.0 * stellar_radius * stellar_radius - radius * radius) /
               (2.0 * stellar_radius * stellar_radius * stellar_radius);
    };
    mean_field::mapping::PhysicalPositionFunctionCoefficient potential_coefficient(
        *fem.domainMapperStateless, *fem.displacement, *fem.compactificationCoordinate, analytic_potential
    );
    mfem::ParGridFunction projected_potential(fem.gravityPotentialFes.get());
    projected_potential.ProjectCoefficient(potential_coefficient);

    const mfem::Vector projected_gradient = project_monopole_gradient(fem, displacement, mass, stellar_radius);

    const AccuracyBudgetMetrics metrics   = measure_monopole_accuracy(
        fem, density, displacement, solution, projected_potential, projected_gradient, mass, stellar_radius
    );

    REQUIRE(std::isfinite(metrics.direct_relative_residual));
    REQUIRE(std::isfinite(metrics.gradient_relative_error));
    REQUIRE(std::isfinite(metrics.potential_relative_error));
    REQUIRE(std::isfinite(metrics.virial_consistency_error));

    record_experiment_result(
        sweep_name, case_name,
        {{"solver_rtol", std::to_string(solver_tolerance)},
         {"quadrature_global_boost", std::to_string(quadrature_boost)},
         {"mesh_file", args.mesh_file}},
        {{"direct_relative_residual", metrics.direct_relative_residual},
         {"gradient_relative_error", metrics.gradient_relative_error},
         {"gradient_projection_relative_error", metrics.gradient_projection_relative_error},
         {"gradient_solution_projection_gap", metrics.gradient_solution_projection_gap},
         {"potential_relative_error", metrics.potential_relative_error},
         {"potential_projection_relative_error", metrics.potential_projection_relative_error},
         {"potential_solution_projection_gap", metrics.potential_solution_projection_gap},
         {"binding_relative_error", metrics.binding_relative_error},
         {"virial_relative_error", metrics.virial_relative_error},
         {"virial_consistency_error", metrics.virial_consistency_error}}
    );
}

TEST_CASE(
    "Uniform Monopole Accuracy Budget: Solver Tolerance",
    tags::gravity_analytic_accuracy
) {
    const mean_field::utils::Args args = test_utils::setup_args();
    constexpr std::array<double, 4> solver_tolerances{1.0e-8, 1.0e-10, 1.0e-12, 1.0e-14};

    for (const double solver_tolerance : solver_tolerances) {
        run_monopole_case("solver_tolerance", "uniform_monopole", args, solver_tolerance, 0);
    }
}

TEST_CASE(
    "Uniform Monopole Accuracy Budget: Quadrature",
    tags::gravity_analytic_accuracy
) {
    const mean_field::utils::Args args = test_utils::setup_args();
    constexpr std::array<int, 3> quadrature_boosts{0, 4, 8};

    for (const int quadrature_boost : quadrature_boosts) {
        run_monopole_case("quadrature", "uniform_monopole", args, 1.0e-13, quadrature_boost);
    }
}

TEST_CASE(
    "Uniform Monopole Accuracy Budget: Projection Decomposition",
    tags::gravity_analytic_accuracy
) {
    run_monopole_case("projection_decomposition", "uniform_monopole", test_utils::setup_args(), 1.0e-13, 0);
}