617 lines
25 KiB
C++
617 lines
25 KiB
C++
#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
|
|
);
|
|
}
|