test(tests): added test suite
The test suite is extensive. Note that LLMs were used to aid in the development of the test suite. All LLM generated code was manually reviewed.
This commit is contained in:
4
tests/quadrature/meson.build
Normal file
4
tests/quadrature/meson.build
Normal file
@@ -0,0 +1,4 @@
|
||||
quadrature_test_sources = files(
|
||||
'policy_meanfield.cpp',
|
||||
'policy.cpp',
|
||||
)
|
||||
199
tests/quadrature/policy.cpp
Normal file
199
tests/quadrature/policy.cpp
Normal file
@@ -0,0 +1,199 @@
|
||||
// Ported from MeanField tests/quadrature/policy.cpp using the consolidated form/role API.
|
||||
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <format>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
||||
#include <mfem.hpp>
|
||||
|
||||
#include "serif/backend/mfem/discretization/quadrature/mfem_resolver.hpp"
|
||||
|
||||
#include "serif/tests/test_tags.hpp"
|
||||
|
||||
namespace quadrature = serif::discretization::quadrature;
|
||||
namespace forms = serif::discretization::forms;
|
||||
namespace blocks = serif::discretization::blocks;
|
||||
using VectorMass = forms::mass<blocks::displacement::vector, blocks::displacement::vector>;
|
||||
using DensityMass = forms::mass<blocks::density::mass, blocks::density::mass>;
|
||||
|
||||
TEST_CASE(
|
||||
"Quadrature Policy Computes Base Orders",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
const quadrature::Policy policy{quadrature::RuleSet{}};
|
||||
quadrature::Query query{.form = forms::form_descriptor<VectorMass>};
|
||||
query.trial_order = 3;
|
||||
query.test_order = 3;
|
||||
query.coefficient_order = 2;
|
||||
query.geometry_weight_order = 1;
|
||||
CHECK(policy.resolve(query).base_order == 9);
|
||||
query.trial_order_reduction = 1;
|
||||
query.test_order_reduction = 2;
|
||||
CHECK(policy.resolve(query).base_order == 6);
|
||||
query.trial_order_reduction = 5;
|
||||
CHECK(policy.resolve(query).base_order == 4);
|
||||
query.base_order = 7;
|
||||
CHECK(policy.resolve(query).base_order == 7);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Quadrature Policy Composes Global Role And Form Boosts",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
quadrature::RuleSet rules;
|
||||
rules.set_fallback_control({.boost = 1});
|
||||
rules.set_role_control(quadrature::QuadratureRole::preconditioner, {.boost = 2});
|
||||
rules.set_form_control<VectorMass>({.boost = 3});
|
||||
const quadrature::Policy policy{rules};
|
||||
const quadrature::Query query{
|
||||
.form = forms::form_descriptor<VectorMass>, .role = quadrature::QuadratureRole::preconditioner, .base_order = 6
|
||||
};
|
||||
const auto result = policy.resolve(query);
|
||||
CHECK(result.base_order == 6);
|
||||
CHECK(result.boost == 6);
|
||||
CHECK(result.order == 12);
|
||||
CHECK_FALSE(result.used_fixed_order);
|
||||
CHECK(policy.resolve({.form = forms::form_descriptor<DensityMass>, .base_order = 4}).order == 5);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Quadrature Fixed Orders Have Defined Precedence",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
quadrature::RuleSet rules;
|
||||
const quadrature::Query query{.form = forms::form_descriptor<VectorMass>, .base_order = 6};
|
||||
rules.set_fallback_control({.fixed_order = 9, .boost = 100});
|
||||
CHECK(quadrature::Policy{rules}.resolve(query).order == 9);
|
||||
rules.set_role_control(quadrature::QuadratureRole::discretization, {.fixed_order = 11, .boost = 200});
|
||||
CHECK(quadrature::Policy{rules}.resolve(query).order == 11);
|
||||
rules.set_form_control<VectorMass>({.fixed_order = 13, .boost = 300});
|
||||
const auto result = quadrature::Policy{rules}.resolve(query);
|
||||
CHECK(result.order == 13);
|
||||
CHECK(result.used_fixed_order);
|
||||
CHECK(result.boost == 0);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Quadrature Policy Rejects Invalid Orders",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
const quadrature::Policy policy{quadrature::RuleSet{}};
|
||||
quadrature::Query query{.form = forms::form_descriptor<VectorMass>};
|
||||
query.base_order = -1;
|
||||
CHECK_THROWS_AS(policy.resolve(query), std::invalid_argument);
|
||||
query.base_order.reset();
|
||||
query.trial_order = -1;
|
||||
CHECK_THROWS_AS(policy.resolve(query), std::invalid_argument);
|
||||
query.trial_order = 1;
|
||||
query.test_order_reduction = -1;
|
||||
CHECK_THROWS_AS(policy.resolve(query), std::invalid_argument);
|
||||
quadrature::RuleSet rules;
|
||||
rules.set_form_control<VectorMass>({.fixed_order = -1});
|
||||
query.test_order_reduction = 0;
|
||||
CHECK_THROWS_AS(quadrature::Policy{rules}.resolve(query), std::invalid_argument);
|
||||
rules.set_form_control<VectorMass>({.boost = -2});
|
||||
CHECK_THROWS_AS(quadrature::Policy{rules}.resolve(query), std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"MFEM Rule Factory Includes Geometry And Dynamic Orders",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
using namespace quadrature::backend::mfem;
|
||||
const MFEMResolver resolver{quadrature::Policy{quadrature::RuleSet{}}};
|
||||
const std::array dynamic_orders{2, 1};
|
||||
MFEMQuadratureContext context{
|
||||
.geometry = mfem::Geometry::CUBE, .geometry_weight_order = 1, .dynamic_orders = dynamic_orders
|
||||
};
|
||||
const auto rule = resolver.resolve<VectorMass>(context);
|
||||
CHECK(rule.resolution.base_order == 10);
|
||||
CHECK(rule.integration_rule == &mfem::IntRules.Get(mfem::Geometry::CUBE, 10));
|
||||
context.geometry_weight_order = -1;
|
||||
CHECK_THROWS_AS(resolver.resolve<VectorMass>(context), std::invalid_argument);
|
||||
context.geometry_weight_order = 0;
|
||||
const std::array invalid_orders{-1};
|
||||
context.dynamic_orders = invalid_orders;
|
||||
CHECK_THROWS_AS(resolver.resolve<VectorMass>(context), std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"MFEM Quadrature Rule Integrates Tensor Polynomial Exactly",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
const quadrature::backend::mfem::MFEMResolver resolver{quadrature::Policy{quadrature::RuleSet{}}};
|
||||
const auto rule = resolver.resolve<VectorMass>({.geometry = mfem::Geometry::CUBE});
|
||||
double integral = 0.0;
|
||||
for (int i = 0; i < rule.integration_rule->GetNPoints(); ++i) {
|
||||
const auto& point = rule.integration_rule->IntPoint(i);
|
||||
integral += point.weight * std::pow(point.x, 4) * std::pow(point.y, 2) * point.z;
|
||||
}
|
||||
CHECK_THAT(integral, Catch::Matchers::WithinAbs(1.0 / 30.0, 1.0e-14));
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Policy Controlled Vector Mass Assembly Matches Overintegrated Reference",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
auto mesh = mfem::Mesh::MakeCartesian3D(1, 1, 1, mfem::Element::HEXAHEDRON, 1.2, 0.9, 1.4);
|
||||
mfem::H1_FECollection collection(3, 3);
|
||||
mfem::FiniteElementSpace space(&mesh, &collection, 3);
|
||||
auto& transformation = *mesh.GetElementTransformation(0);
|
||||
const auto& element = *space.GetFE(0);
|
||||
const quadrature::backend::mfem::MFEMResolver resolver{quadrature::Policy{quadrature::RuleSet{}}};
|
||||
mfem::VectorMassIntegrator controlled;
|
||||
const auto resolution = resolver.configure<VectorMass>(
|
||||
controlled, {.geometry = element.GetGeomType(), .geometry_weight_order = transformation.OrderW()}
|
||||
);
|
||||
mfem::VectorMassIntegrator reference;
|
||||
reference.SetIntRule(&mfem::IntRules.Get(element.GetGeomType(), resolution.order + 8));
|
||||
mfem::DenseMatrix actual, expected;
|
||||
controlled.AssembleElementMatrix(element, transformation, actual);
|
||||
reference.AssembleElementMatrix(element, transformation, expected);
|
||||
actual -= expected;
|
||||
CHECK(actual.FNorm() / expected.FNorm() < 1.0e-12);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Integration Rule Adapter Supports Each Advertised Signature",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
struct ReferenceIntegrator {
|
||||
const mfem::IntegrationRule* selected = nullptr;
|
||||
void SetIntegrationRule(const mfem::IntegrationRule& rule) {
|
||||
selected = &rule;
|
||||
}
|
||||
} reference;
|
||||
struct PointerIntegrator {
|
||||
const mfem::IntegrationRule* selected = nullptr;
|
||||
void SetIntRule(const mfem::IntegrationRule* rule) {
|
||||
selected = rule;
|
||||
}
|
||||
} pointer;
|
||||
struct IntRuleReferenceIntegrator {
|
||||
const mfem::IntegrationRule* selected = nullptr;
|
||||
void SetIntRule(const mfem::IntegrationRule& rule) {
|
||||
selected = &rule;
|
||||
}
|
||||
} int_reference;
|
||||
|
||||
const quadrature::backend::mfem::MFEMResolver resolver{quadrature::Policy{quadrature::RuleSet{}}};
|
||||
const quadrature::backend::mfem::MFEMQuadratureContext context{.geometry = mfem::Geometry::CUBE};
|
||||
resolver.configure<VectorMass>(reference, context);
|
||||
resolver.configure<VectorMass>(pointer, context);
|
||||
resolver.configure<VectorMass>(int_reference, context);
|
||||
CHECK(reference.selected == &mfem::IntRules.Get(mfem::Geometry::CUBE, 6));
|
||||
CHECK(pointer.selected == reference.selected);
|
||||
CHECK(int_reference.selected == reference.selected);
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Discrete Functional Space Can Be Formatted",
|
||||
tags::unit & tags::quadrature
|
||||
) {
|
||||
const blocks::displacement::vector::FunctionalSpace space;
|
||||
CHECK(std::format("{}", space).find("rank=Vector") != std::string::npos);
|
||||
}
|
||||
124
tests/quadrature/policy_meanfield.cpp
Normal file
124
tests/quadrature/policy_meanfield.cpp
Normal file
@@ -0,0 +1,124 @@
|
||||
// Preserve MeanField's independent role/form routing and native RT polynomial-order regressions.
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <string_view>
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include "mfem/fem/bilininteg.hpp"
|
||||
#include "mfem/fem/fespace.hpp"
|
||||
#include "serif/tests/equations/test_equations.hpp"
|
||||
#include "serif/backend/mfem/discretization/quadrature/mfem_resolver.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
namespace quadrature = serif::discretization::quadrature;
|
||||
namespace forms = serif::discretization::forms;
|
||||
namespace blocks = serif::discretization::blocks;
|
||||
using Mass = forms::mass<blocks::displacement::vector, blocks::displacement::vector>;
|
||||
using Divergence = forms::divergence<blocks::displacement::vector, blocks::gravity::potential>;
|
||||
using PressureIntegral = forms::source<::serif::tests::equations::Enthalpy, blocks::barotropic_constant::mass_normalization>;
|
||||
using PressureForce = forms::divergence<blocks::displacement::vector, ::serif::tests::equations::Enthalpy>;
|
||||
using EquilibriumConstant = forms::source<blocks::barotropic_constant::mass_normalization, ::serif::tests::equations::Enthalpy>;
|
||||
|
||||
/** @brief The density projection load has one test operand; its source order is supplied dynamically. */
|
||||
struct DensityProjectionSource final : forms::form
|
||||
{
|
||||
static constexpr std::string_view name = "density projection source";
|
||||
using trial_type = blocks::density::mass;
|
||||
using test_type = blocks::density::mass;
|
||||
using operand_types = serif::utils::types::TypeList<forms::Operand<blocks::density::mass>>;
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("MeanField typed quadrature queries preserve source orders and physical metadata", "[unit][quadrature][meanfield]")
|
||||
{
|
||||
namespace domain = serif::discretization::domain;
|
||||
const quadrature::Policy policy{quadrature::RuleSet{}};
|
||||
const quadrature::backend::mfem::MFEMResolver resolver{policy};
|
||||
constexpr int density_order = quadrature::backend::mfem::resolve_operand_order<forms::Operand<blocks::density::mass>>();
|
||||
const auto density = quadrature::make_query<DensityProjectionSource>(quadrature::QuadratureRole::projection, domain::StellarDomains{}, quadrature::MappingKind::general, 0, density_order, 4, 3);
|
||||
CHECK(density.form == forms::form_descriptor<DensityProjectionSource>);
|
||||
CHECK(density.role == quadrature::QuadratureRole::projection);
|
||||
CHECK(std::ranges::equal(density.domain.domains(), std::array{domain::CoreDomain::name, domain::EnvelopeDomain::name}));
|
||||
CHECK(density.mapping == quadrature::MappingKind::general);
|
||||
CHECK(density.geometry_weight_order == 3);
|
||||
CHECK(density.trial_order == 0);
|
||||
CHECK(density.test_order == 3);
|
||||
CHECK(density.coefficient_order == 4);
|
||||
CHECK(policy.resolve(density).base_order == 10);
|
||||
const std::array dynamic_orders{4};
|
||||
const auto density_rule = resolver.resolve<DensityProjectionSource>({.role = density.role, .geometry = mfem::Geometry::CUBE, .geometry_weight_order = density.geometry_weight_order, .dynamic_orders = dynamic_orders, .domain = density.domain, .mapping = density.mapping});
|
||||
CHECK(density_rule.resolution.base_order == 10);
|
||||
CHECK(density_rule.integration_rule == &mfem::IntRules.Get(mfem::Geometry::CUBE, 10));
|
||||
|
||||
constexpr int constant_order = quadrature::backend::mfem::resolve_operand_order<forms::Operand<blocks::barotropic_constant::mass_normalization>>();
|
||||
constexpr int enthalpy_order = quadrature::backend::mfem::resolve_operand_order<forms::Operand<::serif::tests::equations::Enthalpy>>();
|
||||
const auto equilibrium = quadrature::make_query<EquilibriumConstant>(quadrature::QuadratureRole::discretization, domain::StellarDomains{}, quadrature::MappingKind::none, constant_order, enthalpy_order, 0, 2);
|
||||
CHECK(equilibrium.form == forms::form_descriptor<EquilibriumConstant>);
|
||||
CHECK(equilibrium.role == quadrature::QuadratureRole::discretization);
|
||||
CHECK(std::ranges::equal(equilibrium.domain.domains(), std::array{domain::CoreDomain::name, domain::EnvelopeDomain::name}));
|
||||
CHECK(equilibrium.mapping == quadrature::MappingKind::none);
|
||||
CHECK(equilibrium.geometry_weight_order == 2);
|
||||
CHECK(equilibrium.trial_order == 0);
|
||||
CHECK(equilibrium.test_order == 3);
|
||||
CHECK(policy.resolve(equilibrium).base_order == 5);
|
||||
const auto equilibrium_rule = resolver.resolve<EquilibriumConstant>({.geometry = mfem::Geometry::CUBE, .geometry_weight_order = 2, .domain = equilibrium.domain});
|
||||
CHECK(equilibrium_rule.resolution.base_order == 5);
|
||||
CHECK(equilibrium_rule.integration_rule == &mfem::IntRules.Get(mfem::Geometry::CUBE, 5));
|
||||
|
||||
CHECK_THROWS_AS(resolver.resolve<DensityProjectionSource>({.geometry = mfem::Geometry::CUBE, .geometry_weight_order = -1}), std::invalid_argument);
|
||||
const std::array invalid_orders{-1};
|
||||
CHECK_THROWS_AS(resolver.resolve<PressureForce>({.geometry = mfem::Geometry::CUBE, .dynamic_orders = invalid_orders}), std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST_CASE("MeanField pressure integral and pressure force retain independent quadrature controls", "[unit][quadrature][meanfield]")
|
||||
{
|
||||
quadrature::RuleSet rules;
|
||||
rules.set_form_control<PressureIntegral>({.boost = 3});
|
||||
rules.set_form_control<PressureForce>({.boost = 5});
|
||||
const quadrature::backend::mfem::MFEMResolver resolver{quadrature::Policy{rules}};
|
||||
const std::array dynamic_orders{9};
|
||||
const auto integral = resolver.resolve<PressureIntegral>({.role = quadrature::QuadratureRole::diagnostic, .geometry = mfem::Geometry::CUBE, .geometry_weight_order = 2, .dynamic_orders = dynamic_orders, .domain = serif::discretization::domain::StellarDomains{}, .mapping = quadrature::MappingKind::general});
|
||||
const auto force = resolver.resolve<PressureForce>({.geometry = mfem::Geometry::CUBE, .geometry_weight_order = 2, .dynamic_orders = dynamic_orders, .domain = serif::discretization::domain::StellarDomains{}, .mapping = quadrature::MappingKind::general});
|
||||
CHECK(integral.resolution.base_order == 14);
|
||||
CHECK(integral.resolution.boost == 3);
|
||||
CHECK(integral.resolution.order == 17);
|
||||
CHECK(force.resolution.base_order == 16);
|
||||
CHECK(force.resolution.boost == 5);
|
||||
CHECK(force.resolution.order == 21);
|
||||
CHECK(integral.integration_rule == &mfem::IntRules.Get(mfem::Geometry::CUBE, 17));
|
||||
CHECK(force.integration_rule == &mfem::IntRules.Get(mfem::Geometry::CUBE, 21));
|
||||
}
|
||||
|
||||
TEST_CASE("MeanField quadrature routing generalizes to independent typed forms and every numerical role", "[unit][quadrature][meanfield]")
|
||||
{
|
||||
const std::array descriptors{forms::form_descriptor<Mass>, forms::form_descriptor<Divergence>, forms::form_descriptor<PressureIntegral>, forms::form_descriptor<PressureForce>, forms::form_descriptor<forms::mass<blocks::density::mass, blocks::density::mass>>, forms::form_descriptor<forms::source<blocks::density::mass, blocks::gravity::potential>>, forms::form_descriptor<forms::source<blocks::gravity::potential, blocks::density::mass>>, forms::form_descriptor<forms::projection<::serif::tests::equations::Enthalpy, blocks::density::mass>>};
|
||||
const std::array roles{quadrature::QuadratureRole::discretization, quadrature::QuadratureRole::preconditioner, quadrature::QuadratureRole::diagnostic, quadrature::QuadratureRole::projection};
|
||||
quadrature::RuleSet rules;
|
||||
rules.set_fallback_control({.boost = 3});
|
||||
for (std::size_t form = 0; form < descriptors.size(); ++form)
|
||||
{
|
||||
rules.set_form_control(descriptors[form], {.boost = static_cast<int>(form + 1)});
|
||||
}
|
||||
for (std::size_t role = 0; role < roles.size(); ++role)
|
||||
{
|
||||
rules.set_role_control(roles[role], {.boost = static_cast<int>(2 * role)});
|
||||
}
|
||||
const quadrature::Policy policy{rules};
|
||||
for (std::size_t form = 0; form < descriptors.size(); ++form)
|
||||
{
|
||||
for (std::size_t role = 0; role < roles.size(); ++role)
|
||||
{
|
||||
const auto result = policy.resolve({.form = descriptors[form], .role = roles[role], .base_order = 20});
|
||||
CHECK(result.base_order == 20);
|
||||
CHECK(result.boost == static_cast<int>(3 + form + 1 + 2 * role));
|
||||
CHECK(result.order == 20 + result.boost);
|
||||
CHECK_FALSE(result.used_fixed_order);
|
||||
}
|
||||
}
|
||||
// Replacing an existing rule must not leave an earlier rule shadowing the new physical choice.
|
||||
rules.set_form_control<PressureForce>({.fixed_order = 31});
|
||||
CHECK(quadrature::Policy{rules}.resolve({.form = forms::form_descriptor<PressureForce>, .base_order = 20}).order == 31);
|
||||
CHECK(quadrature::Policy{rules}.resolve({.form = forms::form_descriptor<PressureIntegral>, .base_order = 20}).order == 26);
|
||||
}
|
||||
Reference in New Issue
Block a user