922 lines
33 KiB
C++
922 lines
33 KiB
C++
#include <array>
|
|
#include <catch2/catch_test_macros.hpp>
|
|
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <mfem.hpp>
|
|
#include <stdexcept>
|
|
|
|
import mean_field;
|
|
import test_helpers;
|
|
|
|
using namespace mean_field;
|
|
using Catch::Matchers::WithinAbs;
|
|
|
|
namespace {
|
|
constexpr int dimension = 3;
|
|
|
|
mfem::Vector make_vector(
|
|
const double x,
|
|
const double y,
|
|
const double z
|
|
) {
|
|
mfem::Vector vector(dimension);
|
|
vector(0) = x;
|
|
vector(1) = y;
|
|
vector(2) = z;
|
|
return vector;
|
|
}
|
|
|
|
mfem::DenseMatrix make_identity() {
|
|
mfem::DenseMatrix matrix(dimension);
|
|
matrix = 0.0;
|
|
for (int i = 0; i < dimension; ++i)
|
|
matrix(i, i) = 1.0;
|
|
return matrix;
|
|
}
|
|
|
|
void check_vector(
|
|
const mfem::Vector &actual,
|
|
const mfem::Vector &expected,
|
|
const double tolerance
|
|
) {
|
|
REQUIRE(actual.Size() == expected.Size());
|
|
for (int i = 0; i < actual.Size(); ++i)
|
|
CHECK_THAT(actual(i), WithinAbs(expected(i), tolerance));
|
|
}
|
|
|
|
void check_matrix(
|
|
const mfem::DenseMatrix &actual,
|
|
const mfem::DenseMatrix &expected,
|
|
const double 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), tolerance));
|
|
}
|
|
}
|
|
|
|
struct AnalyticFactors {
|
|
double computational_radius;
|
|
double scale;
|
|
double scale_derivative;
|
|
};
|
|
|
|
AnalyticFactors compute_analytic_factors(
|
|
const double r_star,
|
|
const double r_inf,
|
|
const double coordinate
|
|
) {
|
|
const double radial_extent = r_inf - r_star;
|
|
const double computational_radius = r_star + coordinate * radial_extent;
|
|
const double scale =
|
|
r_star / (computational_radius * (1.0 - coordinate));
|
|
const double scale_derivative =
|
|
scale *
|
|
(1.0 / (1.0 - coordinate) - radial_extent / computational_radius);
|
|
return {
|
|
.computational_radius = computational_radius,
|
|
.scale = scale,
|
|
.scale_derivative = scale_derivative
|
|
};
|
|
}
|
|
|
|
mapping::MappingStatus evaluate_affine_map(
|
|
const mapping::compactification::ExteriorDomainMap &exterior_map,
|
|
const mfem::Vector &reference_position,
|
|
const mfem::DenseMatrix &affine_jacobian,
|
|
const mfem::Vector &offset,
|
|
const double compactification_coordinate,
|
|
const mfem::Vector &compactification_coordinate_gradient,
|
|
mapping::compactification::ExteriorMapResult &result
|
|
) {
|
|
mfem::Vector displaced_position(dimension);
|
|
affine_jacobian.Mult(reference_position, displaced_position);
|
|
displaced_position += offset;
|
|
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
.reference_position = reference_position,
|
|
.displaced_position = displaced_position,
|
|
.displacement_jacobian = affine_jacobian,
|
|
.compactification_coordinate = compactification_coordinate,
|
|
.compactification_coordinate_gradient =
|
|
compactification_coordinate_gradient
|
|
};
|
|
|
|
return exterior_map.Evaluate(input, result);
|
|
}
|
|
} // namespace
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Validates Its Configuration",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
CHECK_NOTHROW(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
)
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 0.0, .r_inf_ref = 4.0}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = -1.0, .r_inf_ref = 4.0}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 2.0, .r_inf_ref = 2.0}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 3.0, .r_inf_ref = 2.0}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 1.0,
|
|
.r_inf_ref = std::numeric_limits<double>::infinity()}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 1.0,
|
|
.r_inf_ref = 4.0,
|
|
.coordinate_tolerance = -1.0e-12}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0, .coordinate_tolerance = 1.0}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
CHECK_THROWS_AS(
|
|
mapping::compactification::KelvinCompactification(
|
|
{.r_star_ref = 1.0,
|
|
.r_inf_ref = 4.0,
|
|
.coordinate_tolerance = std::numeric_limits<double>::quiet_NaN()}
|
|
),
|
|
std::invalid_argument
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Reports Its Configuration",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double coordinate_tolerance = 3.0e-11;
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.25,
|
|
.r_inf_ref = 5.5,
|
|
.coordinate_tolerance = coordinate_tolerance}
|
|
);
|
|
|
|
CHECK(compactification.GetName() == "KelvinCompactification");
|
|
CHECK_THAT(
|
|
compactification.GetReferenceStellarRadius(), WithinAbs(1.25, 0.0)
|
|
);
|
|
CHECK_THAT(
|
|
compactification.GetReferenceInfinityRadius(), WithinAbs(5.5, 0.0)
|
|
);
|
|
CHECK_THAT(
|
|
compactification.GetCoordinateTolerance(),
|
|
WithinAbs(coordinate_tolerance, 0.0)
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Uses The Exterior Coordinate Rather Than "
|
|
"Euclidean Radius",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double tolerance = 0.0;
|
|
constexpr double coordinate = 0.37;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::DenseMatrix displacement_jacobian = make_identity();
|
|
const mfem::Vector displaced_position = make_vector(1.4, -0.2, 0.3);
|
|
const mfem::Vector coordinate_gradient = make_vector(0.2, -0.1, 0.05);
|
|
const mfem::Vector reference_a = make_vector(0.2, 0.1, -0.1);
|
|
const mfem::Vector reference_b = make_vector(12.0, -7.0, 4.0);
|
|
|
|
const mapping::compactification::ExteriorMapInput input_a{
|
|
reference_a, displaced_position, displacement_jacobian, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
const mapping::compactification::ExteriorMapInput input_b{
|
|
reference_b, displaced_position, displacement_jacobian, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
|
|
mapping::compactification::ExteriorMapResult result_a;
|
|
mapping::compactification::ExteriorMapResult result_b;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input_a, result_a) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
compactification.Evaluate(input_b, result_b) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
check_vector(
|
|
result_a.physical_position, result_b.physical_position, tolerance
|
|
);
|
|
check_matrix(
|
|
result_a.mapping_jacobian, result_b.mapping_jacobian, tolerance
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Matches Its Analytic Radial Map",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double r_star = 1.0;
|
|
constexpr double r_inf = 4.0;
|
|
constexpr double radial_extent = r_inf - r_star;
|
|
constexpr double tolerance = 2.0e-12;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = r_star, .r_inf_ref = r_inf}
|
|
);
|
|
const mfem::DenseMatrix identity = make_identity();
|
|
const mfem::Vector coordinate_gradient =
|
|
make_vector(1.0 / radial_extent, 0.0, 0.0);
|
|
|
|
for (const double computational_radius :
|
|
std::array{1.0, 1.25, 2.0, 3.0, 3.75}) {
|
|
CAPTURE(computational_radius);
|
|
|
|
const double coordinate =
|
|
(computational_radius - r_star) / radial_extent;
|
|
const mfem::Vector reference_position =
|
|
make_vector(computational_radius, 0.0, 0.0);
|
|
const mfem::Vector displaced_position(reference_position);
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, identity, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
const double expected_radius =
|
|
r_star * radial_extent / (r_inf - computational_radius);
|
|
const double expected_radial_derivative =
|
|
r_star * radial_extent /
|
|
std::pow(r_inf - computational_radius, 2.0);
|
|
const double expected_tangential_scale =
|
|
expected_radius / computational_radius;
|
|
|
|
const mfem::Vector expected_position =
|
|
make_vector(expected_radius, 0.0, 0.0);
|
|
mfem::DenseMatrix expected_jacobian(dimension);
|
|
expected_jacobian = 0.0;
|
|
expected_jacobian(0, 0) = expected_radial_derivative;
|
|
expected_jacobian(1, 1) = expected_tangential_scale;
|
|
expected_jacobian(2, 2) = expected_tangential_scale;
|
|
|
|
check_vector(result.physical_position, expected_position, tolerance);
|
|
check_matrix(result.mapping_jacobian, expected_jacobian, tolerance);
|
|
CHECK(result.mapping_jacobian.Det() > 0.0);
|
|
}
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Matches Its Full Cartesian Formula",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double r_star = 1.0;
|
|
constexpr double r_inf = 4.0;
|
|
constexpr double coordinate = 0.42;
|
|
constexpr double tolerance = 1.0e-12;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = r_star, .r_inf_ref = r_inf}
|
|
);
|
|
const mfem::Vector reference_position = make_vector(0.8, 0.4, -0.2);
|
|
const mfem::Vector displaced_position = make_vector(1.1, 0.5, -0.1);
|
|
const mfem::Vector coordinate_gradient = make_vector(0.20, -0.10, 0.05);
|
|
|
|
mfem::DenseMatrix displacement_jacobian(dimension);
|
|
displacement_jacobian(0, 0) = 1.10;
|
|
displacement_jacobian(0, 1) = 0.05;
|
|
displacement_jacobian(0, 2) = 0.00;
|
|
displacement_jacobian(1, 0) = -0.02;
|
|
displacement_jacobian(1, 1) = 0.95;
|
|
displacement_jacobian(1, 2) = 0.03;
|
|
displacement_jacobian(2, 0) = 0.01;
|
|
displacement_jacobian(2, 1) = -0.04;
|
|
displacement_jacobian(2, 2) = 1.05;
|
|
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, displacement_jacobian,
|
|
coordinate, coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
const AnalyticFactors factors =
|
|
compute_analytic_factors(r_star, r_inf, coordinate);
|
|
mfem::Vector expected_position(displaced_position);
|
|
expected_position *= factors.scale;
|
|
|
|
mfem::DenseMatrix expected_jacobian(displacement_jacobian);
|
|
expected_jacobian *= factors.scale;
|
|
|
|
for (int i = 0; i < dimension; ++i) {
|
|
for (int j = 0; j < dimension; ++j)
|
|
expected_jacobian(i, j) += displaced_position(i) *
|
|
factors.scale_derivative *
|
|
coordinate_gradient(j);
|
|
}
|
|
|
|
check_vector(result.physical_position, expected_position, tolerance);
|
|
check_matrix(result.mapping_jacobian, expected_jacobian, tolerance);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Jacobian Matches Coordinate Finite Differences",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double base_coordinate = 0.38;
|
|
constexpr double difference_step = 1.0e-6;
|
|
constexpr double tolerance = 3.0e-9;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
|
|
mfem::DenseMatrix affine_jacobian(dimension);
|
|
affine_jacobian(0, 0) = 1.05;
|
|
affine_jacobian(0, 1) = 0.02;
|
|
affine_jacobian(0, 2) = 0.00;
|
|
affine_jacobian(1, 0) = -0.01;
|
|
affine_jacobian(1, 1) = 0.98;
|
|
affine_jacobian(1, 2) = 0.03;
|
|
affine_jacobian(2, 0) = 0.02;
|
|
affine_jacobian(2, 1) = 0.00;
|
|
affine_jacobian(2, 2) = 1.02;
|
|
|
|
const mfem::Vector offset = make_vector(0.04, -0.03, 0.02);
|
|
const mfem::Vector reference_position = make_vector(1.4, 0.3, -0.2);
|
|
const mfem::Vector coordinate_gradient = make_vector(0.11, -0.07, 0.05);
|
|
|
|
mapping::compactification::ExteriorMapResult base_result;
|
|
REQUIRE(
|
|
evaluate_affine_map(
|
|
compactification, reference_position, affine_jacobian, offset,
|
|
base_coordinate, coordinate_gradient, base_result
|
|
) == mapping::MappingStatus::valid
|
|
);
|
|
|
|
for (int coordinate = 0; coordinate < dimension; ++coordinate) {
|
|
mfem::Vector reference_plus(reference_position);
|
|
mfem::Vector reference_minus(reference_position);
|
|
reference_plus(coordinate) += difference_step;
|
|
reference_minus(coordinate) -= difference_step;
|
|
|
|
const double compactification_plus =
|
|
base_coordinate + difference_step * coordinate_gradient(coordinate);
|
|
const double compactification_minus =
|
|
base_coordinate - difference_step * coordinate_gradient(coordinate);
|
|
|
|
mapping::compactification::ExteriorMapResult result_plus;
|
|
mapping::compactification::ExteriorMapResult result_minus;
|
|
|
|
REQUIRE(
|
|
evaluate_affine_map(
|
|
compactification, reference_plus, affine_jacobian, offset,
|
|
compactification_plus, coordinate_gradient, result_plus
|
|
) == mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
evaluate_affine_map(
|
|
compactification, reference_minus, affine_jacobian, offset,
|
|
compactification_minus, coordinate_gradient, result_minus
|
|
) == mapping::MappingStatus::valid
|
|
);
|
|
|
|
for (int component = 0; component < dimension; ++component) {
|
|
const double finite_difference =
|
|
(result_plus.physical_position(component) -
|
|
result_minus.physical_position(component)) /
|
|
(2.0 * difference_step);
|
|
CHECK_THAT(
|
|
finite_difference,
|
|
WithinAbs(
|
|
base_result.mapping_jacobian(component, coordinate),
|
|
tolerance
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Variation Matches State Finite Differences",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double coordinate = 0.46;
|
|
constexpr double difference_step = 1.0e-6;
|
|
constexpr double tolerance = 2.0e-10;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::Vector reference_position = make_vector(1.3, -0.2, 0.4);
|
|
const mfem::Vector displaced_position = make_vector(1.4, -0.1, 0.35);
|
|
const mfem::Vector coordinate_gradient = make_vector(0.12, -0.04, 0.08);
|
|
const mfem::Vector position_direction = make_vector(0.03, -0.05, 0.02);
|
|
|
|
mfem::DenseMatrix displacement_jacobian = make_identity();
|
|
displacement_jacobian(0, 1) = 0.04;
|
|
displacement_jacobian(1, 2) = -0.03;
|
|
displacement_jacobian(2, 0) = 0.02;
|
|
|
|
mfem::DenseMatrix jacobian_direction(dimension);
|
|
jacobian_direction(0, 0) = 0.02;
|
|
jacobian_direction(0, 1) = -0.01;
|
|
jacobian_direction(0, 2) = 0.03;
|
|
jacobian_direction(1, 0) = 0.01;
|
|
jacobian_direction(1, 1) = -0.02;
|
|
jacobian_direction(1, 2) = 0.00;
|
|
jacobian_direction(2, 0) = -0.01;
|
|
jacobian_direction(2, 1) = 0.02;
|
|
jacobian_direction(2, 2) = 0.01;
|
|
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, displacement_jacobian,
|
|
coordinate, coordinate_gradient
|
|
};
|
|
const mapping::compactification::ExteriorMapDirection direction{
|
|
position_direction, jacobian_direction
|
|
};
|
|
|
|
mapping::compactification::ExteriorMapResult base_result;
|
|
mapping::compactification::ExteriorMapVariation variation;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input, base_result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
compactification.EvaluateVariation(
|
|
input, base_result, direction, variation
|
|
) == mapping::MappingStatus::valid
|
|
);
|
|
|
|
mfem::Vector displaced_plus(displaced_position);
|
|
mfem::Vector displaced_minus(displaced_position);
|
|
displaced_plus.Add(difference_step, position_direction);
|
|
displaced_minus.Add(-difference_step, position_direction);
|
|
|
|
mfem::DenseMatrix jacobian_plus(displacement_jacobian);
|
|
mfem::DenseMatrix jacobian_minus(displacement_jacobian);
|
|
jacobian_plus.Add(difference_step, jacobian_direction);
|
|
jacobian_minus.Add(-difference_step, jacobian_direction);
|
|
|
|
const mapping::compactification::ExteriorMapInput input_plus{
|
|
reference_position, displaced_plus, jacobian_plus, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
const mapping::compactification::ExteriorMapInput input_minus{
|
|
reference_position, displaced_minus, jacobian_minus, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
|
|
mapping::compactification::ExteriorMapResult result_plus;
|
|
mapping::compactification::ExteriorMapResult result_minus;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input_plus, result_plus) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
compactification.Evaluate(input_minus, result_minus) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
for (int i = 0; i < dimension; ++i) {
|
|
const double position_finite_difference =
|
|
(result_plus.physical_position(i) -
|
|
result_minus.physical_position(i)) /
|
|
(2.0 * difference_step);
|
|
CHECK_THAT(
|
|
position_finite_difference,
|
|
WithinAbs(variation.physical_position_variation(i), tolerance)
|
|
);
|
|
|
|
for (int j = 0; j < dimension; ++j) {
|
|
const double jacobian_finite_difference =
|
|
(result_plus.mapping_jacobian(i, j) -
|
|
result_minus.mapping_jacobian(i, j)) /
|
|
(2.0 * difference_step);
|
|
CHECK_THAT(
|
|
jacobian_finite_difference,
|
|
WithinAbs(variation.mapping_jacobian_variation(i, j), tolerance)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Preserves Rotational Covariance",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double coordinate = 0.31;
|
|
constexpr double tolerance = 1.0e-12;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::Vector reference_position = make_vector(1.3, 0.4, -0.2);
|
|
const mfem::Vector displaced_position = make_vector(1.4, 0.2, -0.1);
|
|
const mfem::Vector coordinate_gradient = make_vector(0.16, -0.08, 0.03);
|
|
|
|
mfem::DenseMatrix displacement_jacobian = make_identity();
|
|
displacement_jacobian(0, 1) = 0.05;
|
|
displacement_jacobian(1, 0) = -0.02;
|
|
displacement_jacobian(2, 1) = 0.03;
|
|
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, displacement_jacobian,
|
|
coordinate, coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult result;
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
mfem::DenseMatrix rotation(dimension);
|
|
rotation = 0.0;
|
|
rotation(0, 1) = -1.0;
|
|
rotation(1, 0) = 1.0;
|
|
rotation(2, 2) = 1.0;
|
|
|
|
mfem::Vector rotated_reference(dimension);
|
|
mfem::Vector rotated_displaced(dimension);
|
|
mfem::Vector rotated_coordinate_gradient(dimension);
|
|
rotation.Mult(reference_position, rotated_reference);
|
|
rotation.Mult(displaced_position, rotated_displaced);
|
|
rotation.Mult(coordinate_gradient, rotated_coordinate_gradient);
|
|
|
|
mfem::DenseMatrix temporary(dimension);
|
|
mfem::DenseMatrix rotated_displacement_jacobian(dimension);
|
|
mfem::Mult(rotation, displacement_jacobian, temporary);
|
|
mfem::MultABt(temporary, rotation, rotated_displacement_jacobian);
|
|
|
|
const mapping::compactification::ExteriorMapInput rotated_input{
|
|
rotated_reference, rotated_displaced, rotated_displacement_jacobian,
|
|
coordinate, rotated_coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult rotated_result;
|
|
REQUIRE(
|
|
compactification.Evaluate(rotated_input, rotated_result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
mfem::Vector expected_position(dimension);
|
|
rotation.Mult(result.physical_position, expected_position);
|
|
|
|
mfem::DenseMatrix expected_jacobian(dimension);
|
|
mfem::Mult(rotation, result.mapping_jacobian, temporary);
|
|
mfem::MultABt(temporary, rotation, expected_jacobian);
|
|
|
|
check_vector(
|
|
rotated_result.physical_position, expected_position, tolerance
|
|
);
|
|
check_matrix(rotated_result.mapping_jacobian, expected_jacobian, tolerance);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Is Continuous At The Mesh Defined Stellar Surface",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double tolerance = 1.0e-14;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::Vector reference_position = make_vector(
|
|
-0.5260553366425769, 0.5260553366425769, -0.6553163792879153
|
|
);
|
|
const mfem::Vector displaced_position = make_vector(-0.55, 0.51, -0.63);
|
|
const mfem::Vector coordinate_gradient = make_vector(-0.18, 0.18, -0.22);
|
|
const mfem::DenseMatrix displacement_jacobian = make_identity();
|
|
|
|
REQUIRE(reference_position.Norml2() < 1.0);
|
|
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, displacement_jacobian, 0.0,
|
|
coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
check_vector(result.physical_position, displaced_position, tolerance);
|
|
CHECK(result.mapping_jacobian.Det() > 0.0);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Has Correct Infinity And Coordinate Bound "
|
|
"Behavior",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double r_star = 1.0;
|
|
constexpr double r_inf = 4.0;
|
|
constexpr double radial_extent = r_inf - r_star;
|
|
constexpr double coordinate_tolerance = 1.0e-12;
|
|
constexpr double tolerance = 2.0e-11;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = r_star,
|
|
.r_inf_ref = r_inf,
|
|
.coordinate_tolerance = coordinate_tolerance}
|
|
);
|
|
const mfem::DenseMatrix identity = make_identity();
|
|
const mfem::Vector coordinate_gradient =
|
|
make_vector(1.0 / radial_extent, 0.0, 0.0);
|
|
|
|
for (const double coordinate :
|
|
std::array{0.0, 0.25, 0.75, 0.95, 0.99, 0.999}) {
|
|
CAPTURE(coordinate);
|
|
|
|
const double computational_radius = r_star + coordinate * radial_extent;
|
|
const mfem::Vector reference_position =
|
|
make_vector(computational_radius, 0.0, 0.0);
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, reference_position, identity, coordinate,
|
|
coordinate_gradient
|
|
};
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
CHECK_THAT(
|
|
result.physical_position.Norml2() * (1.0 - coordinate),
|
|
WithinAbs(r_star, tolerance)
|
|
);
|
|
}
|
|
|
|
const mfem::Vector reference_position = make_vector(r_inf, 0.0, 0.0);
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, reference_position, identity, 1.0,
|
|
coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::at_compactified_infinity
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, reference_position, identity,
|
|
1.0 - 0.5 * coordinate_tolerance, coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::at_compactified_infinity
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, reference_position, identity,
|
|
1.0 + 0.5 * coordinate_tolerance, coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::at_compactified_infinity
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, reference_position, identity,
|
|
1.0 + 2.0 * coordinate_tolerance, coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::outside_reference_domain
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, reference_position, identity,
|
|
-2.0 * coordinate_tolerance, coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::outside_reference_domain
|
|
);
|
|
|
|
const mfem::Vector surface_position = make_vector(0.97, 0.0, 0.0);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{surface_position, surface_position, identity,
|
|
-0.5 * coordinate_tolerance, coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::valid
|
|
);
|
|
check_vector(result.physical_position, surface_position, tolerance);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Rejects Invalid Inputs And Inverted Maps",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
|
|
const mfem::Vector reference_position = make_vector(2.0, 0.0, 0.0);
|
|
const mfem::Vector displaced_position(reference_position);
|
|
const mfem::Vector coordinate_gradient = make_vector(1.0 / 3.0, 0.0, 0.0);
|
|
const mfem::Vector zero_gradient = make_vector(0.0, 0.0, 0.0);
|
|
const mfem::DenseMatrix identity = make_identity();
|
|
mapping::compactification::ExteriorMapResult result;
|
|
|
|
mfem::Vector wrong_dimension(2);
|
|
wrong_dimension = 1.0;
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{wrong_dimension, displaced_position, identity, 1.0 / 3.0,
|
|
coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::invalid_dimension
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, displaced_position, identity, 1.0 / 3.0,
|
|
wrong_dimension},
|
|
result
|
|
) == mapping::MappingStatus::invalid_dimension
|
|
);
|
|
|
|
mfem::Vector non_finite_position(reference_position);
|
|
non_finite_position(1) = std::numeric_limits<double>::quiet_NaN();
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{non_finite_position, displaced_position, identity, 1.0 / 3.0,
|
|
coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::non_finite_input
|
|
);
|
|
|
|
mfem::Vector non_finite_gradient(coordinate_gradient);
|
|
non_finite_gradient(2) = std::numeric_limits<double>::infinity();
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, displaced_position, identity, 1.0 / 3.0,
|
|
non_finite_gradient},
|
|
result
|
|
) == mapping::MappingStatus::non_finite_input
|
|
);
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, displaced_position, identity,
|
|
std::numeric_limits<double>::quiet_NaN(), coordinate_gradient},
|
|
result
|
|
) == mapping::MappingStatus::non_finite_input
|
|
);
|
|
|
|
mfem::DenseMatrix singular_displacement_jacobian(dimension);
|
|
singular_displacement_jacobian = 0.0;
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, displaced_position,
|
|
singular_displacement_jacobian, 1.0 / 3.0, zero_gradient},
|
|
result
|
|
) == mapping::MappingStatus::non_positive_determinant
|
|
);
|
|
|
|
mfem::DenseMatrix inverted_displacement_jacobian = make_identity();
|
|
inverted_displacement_jacobian(0, 0) = -1.0;
|
|
CHECK(
|
|
compactification.Evaluate(
|
|
{reference_position, displaced_position,
|
|
inverted_displacement_jacobian, 1.0 / 3.0, zero_gradient},
|
|
result
|
|
) == mapping::MappingStatus::non_positive_determinant
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Variation Rejects Invalid Inputs",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::Vector reference_position = make_vector(2.0, 0.0, 0.0);
|
|
const mfem::Vector displaced_position(reference_position);
|
|
const mfem::Vector coordinate_gradient = make_vector(1.0 / 3.0, 0.0, 0.0);
|
|
const mfem::DenseMatrix identity = make_identity();
|
|
const mapping::compactification::ExteriorMapInput input{
|
|
reference_position, displaced_position, identity, 1.0 / 3.0,
|
|
coordinate_gradient
|
|
};
|
|
|
|
mapping::compactification::ExteriorMapResult result;
|
|
REQUIRE(
|
|
compactification.Evaluate(input, result) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
const mfem::Vector valid_position_direction =
|
|
make_vector(0.01, -0.02, 0.03);
|
|
const mfem::DenseMatrix valid_jacobian_direction = make_identity();
|
|
mapping::compactification::ExteriorMapVariation variation;
|
|
|
|
mfem::Vector wrong_dimension(2);
|
|
wrong_dimension = 0.0;
|
|
CHECK(
|
|
compactification.EvaluateVariation(
|
|
input, result, {wrong_dimension, valid_jacobian_direction},
|
|
variation
|
|
) == mapping::MappingStatus::invalid_dimension
|
|
);
|
|
|
|
mfem::DenseMatrix wrong_jacobian_dimension(2);
|
|
wrong_jacobian_dimension = 0.0;
|
|
CHECK(
|
|
compactification.EvaluateVariation(
|
|
input, result, {valid_position_direction, wrong_jacobian_dimension},
|
|
variation
|
|
) == mapping::MappingStatus::invalid_dimension
|
|
);
|
|
|
|
mfem::Vector non_finite_direction(valid_position_direction);
|
|
non_finite_direction(0) = std::numeric_limits<double>::quiet_NaN();
|
|
CHECK(
|
|
compactification.EvaluateVariation(
|
|
input, result, {non_finite_direction, valid_jacobian_direction},
|
|
variation
|
|
) == mapping::MappingStatus::non_finite_input
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Kelvin Compactification Evaluations Are Independent",
|
|
tags::unit &tags::mapping &tags::kelvin
|
|
) {
|
|
constexpr double tolerance = 0.0;
|
|
|
|
mapping::compactification::KelvinCompactification compactification(
|
|
{.r_star_ref = 1.0, .r_inf_ref = 4.0}
|
|
);
|
|
const mfem::DenseMatrix identity = make_identity();
|
|
const mfem::Vector gradient_a = make_vector(0.12, 0.03, -0.02);
|
|
const mfem::Vector gradient_b = make_vector(-0.04, 0.15, 0.01);
|
|
const mfem::Vector reference_a = make_vector(1.5, 0.2, 0.1);
|
|
const mfem::Vector reference_b = make_vector(2.5, -0.3, 0.4);
|
|
|
|
const mapping::compactification::ExteriorMapInput input_a{
|
|
reference_a, reference_a, identity, 0.25, gradient_a
|
|
};
|
|
const mapping::compactification::ExteriorMapInput input_b{
|
|
reference_b, reference_b, identity, 0.70, gradient_b
|
|
};
|
|
|
|
mapping::compactification::ExteriorMapResult first_a;
|
|
mapping::compactification::ExteriorMapResult result_b;
|
|
mapping::compactification::ExteriorMapResult second_a;
|
|
|
|
REQUIRE(
|
|
compactification.Evaluate(input_a, first_a) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
compactification.Evaluate(input_b, result_b) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
REQUIRE(
|
|
compactification.Evaluate(input_a, second_a) ==
|
|
mapping::MappingStatus::valid
|
|
);
|
|
|
|
check_vector(
|
|
first_a.physical_position, second_a.physical_position, tolerance
|
|
);
|
|
check_matrix(
|
|
first_a.mapping_jacobian, second_a.mapping_jacobian, tolerance
|
|
);
|
|
} |