#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) {
    for (int index = 0; index < fem.vacuum_tdof_rho.Size(); ++index) {
        density(fem.vacuum_tdof_rho[index]) = 0.0;
    }
}

static int diagnostic_quadrature_order(const mean_field::fem::FEM& fem) {
    return 2 * std::max(fem.L2_fes->GetMaxElementOrder(), fem.RT_fes->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
) {
    static_cast<void>(displacement);

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

    const int vacuum_attribute = fem.domain_mapper_stateless->GetVacuumElementAttribute();
    const int quadrature_order = diagnostic_quadrature_order(fem);

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

        mfem::Array<int> gravity_dofs;
        mfem::DofTransformation* gravity_transform = fem.RT_fes->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 mapping_jacobian(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);
            fem.mapping->GetPhysicalPoint(*transformation, point, 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);
            }

            fem.mapping->ComputeJacobian(*transformation, mapping_jacobian);
            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.RT_fes->GetTrueVSize());
    true_rhs = 0.0;
    const mfem::Operator* prolongation = fem.RT_fes->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 = assemble_monopole_projection_rhs(
        fem,
        displacement,
        mass,
        stellar_radius
    );

    mean_field::operators::PreparedMappedHDivMassOperator mass_operator(
        fem,
        *fem.domain_mapper_stateless
    );
    mass_operator.Prepare(displacement_true);

    mfem::CGSolver solver(fem.RT_fes->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(fem.RT_fes->GetTrueVSize());
    projected_gradient = 0.0;
    solver.Mult(projection_rhs, projected_gradient);

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

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

    REQUIRE(std::isfinite(relative_residual));
    REQUIRE(relative_residual < 1.0e-8);
    return projected_gradient;
}

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.domain_mapper_stateless
    );
    mass_operator.Prepare(displacement_true);

    mfem::Vector difference(calculated);
    difference -= reference;
    mfem::Vector difference_action;
    mfem::Vector reference_action;
    mass_operator.Mult(difference, difference_action);
    mass_operator.Mult(reference, reference_action);

    const double difference_energy = global_dot(difference, difference_action, fem.RT_fes->GetComm());
    const double reference_energy = global_dot(reference, reference_action, fem.RT_fes->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 = fem.domain_mapper_stateless->GetVacuumElementAttribute();
    const int quadrature_order = diagnostic_quadrature_order(fem);
    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);
    mfem::DenseMatrix mapping_jacobian(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);

            fem.mapping->GetPhysicalPoint(*transformation, point, physical_position);
            fem.mapping->ComputeJacobian(*transformation, mapping_jacobian);
            const double mapping_determinant = mapping_jacobian.Det();
            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.L2_fes->GetComm());
    MPI_Allreduce(&local_virial, &energies.virial, 1, MPI_DOUBLE, MPI_SUM, fem.L2_fes->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
    );

    const std::array<int, GravityFieldForm::value_block_count> value_sizes{
        fem.L2_fes->GetTrueVSize(), fem.Vec_H1_fes->GetTrueVSize(),
        fem.RT_fes->GetTrueVSize(), fem.L2_fes->GetTrueVSize()
    };
    const std::array<int, GravityFieldForm::residual_block_count> residual_sizes{
        fem.RT_fes->GetTrueVSize(), fem.L2_fes->GetTrueVSize()
    };
    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.domain_mapper_stateless
    );
    mean_field::operators::GravityFieldJacobianOperator jacobian(
        fem,
        *fem.domain_mapper_stateless,
        linearization_context,
        layout.value_offsets(),
        layout.residual_offsets()
    );
    mean_field::operators::GravityFieldOperator field_operator(
        fem,
        *fem.domain_mapper_stateless,
        linearization_context,
        layout.value_offsets(),
        jacobian
    );
    mean_field::operators::context::gravity_field::GravityFieldGeometryContext geometry_context(
        fem,
        *fem.domain_mapper_stateless
    );
    mean_field::operators::ReducedGravityFieldOperator reduced_operator(
        field_operator,
        geometry_context,
        displacement_true
    );

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

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

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

    return global_norm(residual, fem.L2_fes->GetComm()) /
        std::max(global_norm(right_hand_side, fem.L2_fes->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.RT_fes.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 = fem.domain_mapper_stateless->GetVacuumElementAttribute();
    const int quadrature_order = diagnostic_quadrature_order(fem);
    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);
    mfem::DenseMatrix mapping_jacobian(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);
            fem.mapping->GetPhysicalPoint(*transformation, point, physical_position);
            fem.mapping->ComputeJacobian(*transformation, mapping_jacobian);
            const double mapping_determinant = mapping_jacobian.Det();
            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.L2_fes->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.L2_fes->GetComm());
    REQUIRE(projection_potential_norm > 0.0);
    metrics.potential_solution_projection_gap = global_norm(potential_difference, fem.L2_fes->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.mapping != nullptr);
    REQUIRE(fem.domain_mapper_stateless != 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.Vec_H1_fes.get());
    displacement = 0.0;
    fem.mapping->ResetDisplacement();
    mean_field::physics::update_stiffness_matrix(fem);

    mfem::GridFunction density(fem.L2_fes.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::grav_potential_new(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.mapping,
        analytic_potential
    );
    mfem::ParGridFunction projected_potential(fem.L2_fes.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 & tags::accuracy & tags::integration) {
    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 & tags::accuracy & tags::integration) {
    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 & tags::accuracy & tags::integration) {
    run_monopole_case(
        "projection_decomposition",
        "uniform_monopole",
        test_utils::setup_args(),
        1.0e-13,
        0
    );
}