tboudreaux/MeanField
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(libmeanfield): variadic refactor

Browse Source 
also added normaliztion operator
This commit is contained in:
Emily Boudreaux
2026-09-06 10:15:00 -04:00
parent 71423d543f
commit 76818f2f82
63 changed files with 28794 additions and 1119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

828
tests/normalization/physical_riesz.cpp Normal file
View File

@@ -0,0 +1,828 @@
#include <algorithm>
#include <array>
#include <cmath>
#include <concepts>
#include <limits>
#include <span>
#include <stdexcept>
#include <utility>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <mfem.hpp>
import mean_field;
import test_helpers;
namespace {
namespace blocks = mean_field::utils::blocks;
namespace normalization = mean_field::normalization;
namespace models = mean_field::models;
struct ModelWithoutFixedTotalMass final { };
template <typename Model>
concept SupportsModelDerivedStellarScales = requires(
const normalization::PhysicalRieszDiagonal<> &policy,
const Model &model
) {
{
normalization::deriveStellarCharacteristicScales(policy, model)
} -> std::same_as<normalization::StellarCharacteristicScales>;
};
struct TestValue final : blocks::value_block_base { };
struct TestResidual final : blocks::residual_block_base { };
using TestForm = blocks::block_form<
blocks::type_list<TestValue>,
blocks::type_list<TestResidual>>;
using GlobalSpecificEnergyNormalization = models::CoordinateNormalization<
models::RieszTopology::global_scalar,
models::PhysicalScaleLaw::specific_energy>;
using VolumeSpecificEnergyNormalization = models::CoordinateNormalization<
models::RieszTopology::scalar_volume_l2,
models::PhysicalScaleLaw::specific_energy>;
class SelfDescribingMagneticSpecificEnergy final {
public:
struct Parameters final {
double target;
};
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
SelfDescribingMagneticSpecificEnergy,
"NormalizationMockMagneticSpecificEnergy",
models::DependsOn<blocks::density::mass::value>,
models::Affects<blocks::enthalpy::specific::residual>,
models::GlobalScalarNormalization<
models::PhysicalScaleLaw::dimensionless,
models::PhysicalScaleLaw::specific_energy>>;
explicit constexpr SelfDescribingMagneticSpecificEnergy(const Parameters parameters) noexcept
: m_target(parameters.target) {
}
private:
double m_target;
};
class MissingGeneratedNormalization final {
public:
struct Parameters final {
double target;
};
using ModelDefinition = mean_field::integral::FixedWithMultiplier<
MissingGeneratedNormalization,
"NormalizationMockMissing",
models::DependsOn<blocks::density::mass::value>,
models::Affects<blocks::enthalpy::specific::residual>>;
explicit constexpr MissingGeneratedNormalization(const Parameters parameters) noexcept
: m_target(parameters.target) {
}
private:
double m_target;
};
class GeneratedVolumeCoordinateWithoutMetricSource final {
public:
struct Parameters final {
double target;
};
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
GeneratedVolumeCoordinateWithoutMetricSource,
"NormalizationMockVolumeCoordinate",
models::DependsOn<blocks::density::mass::value>,
models::Affects<blocks::enthalpy::specific::residual>,
models::GeneratedNormalization<
VolumeSpecificEnergyNormalization,
GlobalSpecificEnergyNormalization>>;
explicit constexpr GeneratedVolumeCoordinateWithoutMetricSource(const Parameters parameters) noexcept
: m_target(parameters.target) {
}
private:
double m_target;
};
struct MalformedGeneratedNormalization final { };
class MalformedGeneratedNormalizationConstraint final {
public:
struct Parameters final {
double target;
};
using ModelDefinition = mean_field::integral::FixedWithMultiplier<
MalformedGeneratedNormalizationConstraint,
"NormalizationMockMalformed",
models::DependsOn<blocks::density::mass::value>,
models::Affects<blocks::enthalpy::specific::residual>,
MalformedGeneratedNormalization>;
explicit constexpr MalformedGeneratedNormalizationConstraint(const Parameters parameters) noexcept
: m_target(parameters.target) {
}
private:
double m_target;
};
template <typename Specification>
using GeneratedValueBlock = blocks::generated_value_block<
models::PhysicalCoordinateFor<Specification>>;
template <typename Specification>
using GeneratedMultiplierBlock = blocks::generated_value_block<
models::MultiplierFor<Specification>>;
template <typename Specification>
using GeneratedResidualBlock = blocks::generated_residual_block<
models::ResidualFor<Specification>>;
using SelfDescribingValue = GeneratedValueBlock<SelfDescribingMagneticSpecificEnergy>;
using SelfDescribingResidual = GeneratedResidualBlock<SelfDescribingMagneticSpecificEnergy>;
using SelfDescribingForm = blocks::block_form<
blocks::type_list<SelfDescribingValue>,
blocks::type_list<SelfDescribingResidual>>;
using MissingValue = GeneratedMultiplierBlock<MissingGeneratedNormalization>;
using MissingResidual = GeneratedResidualBlock<MissingGeneratedNormalization>;
using MissingNormalizationForm = blocks::block_form<
blocks::type_list<MissingValue>,
blocks::type_list<MissingResidual>>;
using UnpreparedVolumeValue = GeneratedValueBlock<GeneratedVolumeCoordinateWithoutMetricSource>;
using UnpreparedVolumeResidual = GeneratedResidualBlock<GeneratedVolumeCoordinateWithoutMetricSource>;
using UnpreparedVolumeForm = blocks::block_form<
blocks::type_list<UnpreparedVolumeValue>,
blocks::type_list<UnpreparedVolumeResidual>>;
class DenseOperator final : public mfem::Operator {
public:
explicit DenseOperator(const mfem::DenseMatrix &matrix)
: mfem::Operator(matrix.Height(), matrix.Width()),
m_matrix(matrix) {
}
void Mult(
const mfem::Vector &input,
mfem::Vector &output
) const override {
m_matrix.Mult(input, output);
}
private:
mfem::DenseMatrix m_matrix;
};
class DenseInverseSolver final : public mfem::Solver {
public:
explicit DenseInverseSolver(const mfem::DenseMatrix &inverse)
: mfem::Solver(inverse.Height(), inverse.Width()),
m_inverse(inverse) {
}
void SetOperator(const mfem::Operator &operation) override {
if (operation.Height() != Height() || operation.Width() != Width()) {
throw std::invalid_argument("The dense inverse received an incompatible operator.");
}
m_boundOperator = &operation;
++m_bindings;
}
void Mult(
const mfem::Vector &input,
mfem::Vector &output
) const override {
if (m_boundOperator == nullptr) {
throw std::logic_error("The dense inverse must be bound before application.");
}
m_inverse.Mult(input, output);
}
[[nodiscard]] const mfem::Operator *BoundOperator() const noexcept {
return m_boundOperator;
}
[[nodiscard]] int Bindings() const noexcept {
return m_bindings;
}
private:
mfem::DenseMatrix m_inverse;
const mfem::Operator *m_boundOperator{nullptr};
int m_bindings{0};
};
[[nodiscard]] mfem::Vector vector(std::initializer_list<double> values) {
mfem::Vector result(static_cast<int>(values.size()));
int index = 0;
for (const double value : values) {
result(index++) = value;
}
return result;
}
void checkVector(
const mfem::Vector &actual,
const mfem::Vector &expected,
const double epsilon = 2.0e-13
) {
REQUIRE(actual.Size() == expected.Size());
for (int index = 0; index < actual.Size(); ++index) {
CHECK(actual(index) == Catch::Approx(expected(index)).epsilon(epsilon).margin(1.0e-300));
}
}
} // namespace
TEST_CASE(
"Pointer-Retaining Normalization Operators Reject Temporary Dependencies",
"[normalization][type][lifetime]"
) {
using Map = normalization::DiagonalNormalization;
STATIC_CHECK(std::constructible_from<
normalization::ScaledJacobianOperator,
const DenseOperator &,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledJacobianOperator,
DenseOperator &&,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledJacobianOperator,
const DenseOperator &&,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledJacobianOperator,
const DenseOperator &,
Map &&>);
STATIC_CHECK(std::constructible_from<
normalization::ScaledInverseOperator,
const DenseOperator &,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledInverseOperator,
DenseOperator &&,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledInverseOperator,
const DenseOperator &,
Map &&>);
STATIC_CHECK(std::constructible_from<
normalization::ScaledPreconditioner,
DenseInverseSolver &,
const DenseOperator &,
const DenseOperator &,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledPreconditioner,
DenseInverseSolver &&,
const DenseOperator &,
const DenseOperator &,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledPreconditioner,
DenseInverseSolver &,
DenseOperator &&,
const DenseOperator &,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledPreconditioner,
DenseInverseSolver &,
const DenseOperator &,
DenseOperator &&,
const Map &>);
STATIC_CHECK_FALSE(std::constructible_from<
normalization::ScaledPreconditioner,
DenseInverseSolver &,
const DenseOperator &,
const DenseOperator &,
Map &&>);
}
TEST_CASE("Characteristic Stellar Scales Satisfy Gravity Virial And Rotation Identities", "[normalization][physics]") {
using namespace mean_field;
constexpr double mass = 7.0;
constexpr double radius = 3.0;
constexpr double gravity = 5.0;
const auto scales = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{mass}, dimensions::LengthValue{radius}, gravity
);
CHECK(scales.density == Catch::Approx(mass / std::pow(radius, 3)));
CHECK(scales.acceleration == Catch::Approx(gravity * mass / std::pow(radius, 2)));
CHECK(scales.specificEnergy == Catch::Approx(gravity * mass / radius));
CHECK(scales.pressure == Catch::Approx(gravity * mass * mass / std::pow(radius, 4)));
CHECK(scales.angularVelocity == Catch::Approx(std::sqrt(gravity * mass / std::pow(radius, 3))));
CHECK(scales.angularMomentum == Catch::Approx(mass * std::sqrt(gravity * mass * radius)));
// Hydrostatic/virial energy scales agree: P R^3 = M Phi = F R.
const double virial = scales.pressure * std::pow(radius, 3);
CHECK(virial == Catch::Approx(mass * scales.specificEnergy).epsilon(2.0e-15));
CHECK(virial == Catch::Approx(scales.force * radius).epsilon(2.0e-15));
// Omega_0 is the Kepler/break-up scale and J_0 = M R^2 Omega_0.
CHECK(scales.angularVelocity * scales.angularVelocity * radius ==
Catch::Approx(scales.acceleration).epsilon(2.0e-15));
CHECK(scales.angularMomentum ==
Catch::Approx(mass * radius * radius * scales.angularVelocity).epsilon(2.0e-15));
}
TEST_CASE("Characteristic Scales Obey The Expected Stellar Homology Exponents", "[normalization][physics]") {
using namespace mean_field;
const auto reference = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{2.5}, dimensions::LengthValue{4.0}, 3.0
);
constexpr double massFactor = 11.0;
constexpr double radiusFactor = 0.2;
constexpr double gravityFactor = 7.0;
const auto transformed = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{2.5 * massFactor},
dimensions::LengthValue{4.0 * radiusFactor},
3.0 * gravityFactor
);
CHECK(transformed.density / reference.density ==
Catch::Approx(massFactor / std::pow(radiusFactor, 3)).epsilon(4.0e-15));
CHECK(transformed.acceleration / reference.acceleration ==
Catch::Approx(gravityFactor * massFactor / std::pow(radiusFactor, 2)).epsilon(4.0e-15));
CHECK(transformed.inverseTimeSquared / reference.inverseTimeSquared ==
Catch::Approx(gravityFactor * massFactor / std::pow(radiusFactor, 3)).epsilon(4.0e-15));
CHECK(transformed.specificEnergy / reference.specificEnergy ==
Catch::Approx(gravityFactor * massFactor / radiusFactor).epsilon(4.0e-15));
CHECK(transformed.pressure / reference.pressure ==
Catch::Approx(gravityFactor * massFactor * massFactor / std::pow(radiusFactor, 4)).epsilon(4.0e-15));
CHECK(transformed.angularVelocity / reference.angularVelocity == Catch::Approx(
std::sqrt(gravityFactor * massFactor / std::pow(radiusFactor, 3))
).epsilon(4.0e-15));
CHECK(transformed.angularMomentum / reference.angularMomentum == Catch::Approx(
massFactor * std::sqrt(gravityFactor * massFactor * radiusFactor)
).epsilon(4.0e-15));
}
TEST_CASE("Physical Block Scales Distinguish Invariants From Numerical Phase Conditions", "[normalization][physics]") {
using namespace mean_field;
const auto scales = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{9.0}, dimensions::LengthValue{2.0}, 4.0
);
CHECK(normalization::physicalScale<blocks::density::mass::value>(scales) == scales.density);
CHECK(normalization::physicalScale<blocks::gravity::gradient::value>(scales) == scales.acceleration);
CHECK(normalization::physicalScale<blocks::gravity::poisson::residual>(scales) == scales.inverseTimeSquared);
CHECK(normalization::physicalScale<blocks::fixed_total_mass::mass_normalization::residual>(scales) == 9.0);
CHECK(normalization::physicalScale<blocks::fixed_angular_momentum::angular_velocity::value>(scales) ==
scales.angularVelocity);
CHECK(normalization::physicalScale<blocks::fixed_angular_momentum::angular_velocity::residual>(scales) ==
scales.angularMomentum);
// The central-density condition is implemented as h(0)-h_target, so its residual scale is energy/mass,
// despite the physical target being expressed as a density.
CHECK(normalization::physicalScale<blocks::fixed_central_density::central_value::residual>(scales) ==
scales.specificEnergy);
CHECK(normalization::physicalScale<blocks::fixed_central_density::central_value::residual>(scales) !=
scales.density);
}
TEST_CASE(
"Generated Physical Riesz Laws Come From A Self-Describing Physics Specification",
"[normalization][type][extension]"
) {
using namespace mean_field;
using ValueTraits = normalization::PhysicalRieszBlockTraits<SelfDescribingValue>;
using ResidualTraits = normalization::PhysicalRieszBlockTraits<SelfDescribingResidual>;
STATIC_CHECK(models::SelfDescribingModelSpecification<SelfDescribingMagneticSpecificEnergy>);
STATIC_CHECK(models::CompleteGeneratedNormalizationFor<SelfDescribingMagneticSpecificEnergy>);
STATIC_CHECK(operators::StellarEquilibriumSpecificationCompilable<SelfDescribingMagneticSpecificEnergy>);
STATIC_CHECK(normalization::GeneratedValuePhysicalRieszNormalizable<
models::PhysicalCoordinateFor<SelfDescribingMagneticSpecificEnergy>>);
STATIC_CHECK(normalization::GeneratedResidualPhysicalRieszNormalizable<
models::ResidualFor<SelfDescribingMagneticSpecificEnergy>>);
STATIC_CHECK(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<
SelfDescribingMagneticSpecificEnergy>);
STATIC_CHECK(normalization::CompilableNormalizationFor<
normalization::PhysicalRieszDiagonal<>,
SelfDescribingForm>);
STATIC_CHECK(normalization::RegisteredStellarSpecificationNormalization<
SelfDescribingMagneticSpecificEnergy>);
STATIC_CHECK(normalization::CompleteStellarSpecificationNormalizationFor<
SelfDescribingMagneticSpecificEnergy,
SelfDescribingForm>);
STATIC_CHECK(ValueTraits::Method::topology == normalization::RieszTopology::global_scalar);
STATIC_CHECK(ValueTraits::Method::scale == normalization::PhysicalScaleKind::dimensionless);
STATIC_CHECK(ResidualTraits::Method::topology == normalization::RieszTopology::global_scalar);
STATIC_CHECK(ResidualTraits::Method::scale == normalization::PhysicalScaleKind::specific_energy);
const auto scales = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{9.0}, dimensions::LengthValue{2.0}, 4.0
);
const blocks::form_layout<SelfDescribingForm> layout({1}, {1});
normalization::DiagonalNormalizationBuilder<SelfDescribingForm> builder(layout);
normalization::StellarSpecificationNormalizationContribution<
SelfDescribingMagneticSpecificEnergy>::Apply(builder, scales);
const normalization::DiagonalNormalization map = std::move(builder).Build();
REQUIRE(map.StateFactors().Size() == 1);
REQUIRE(map.ResidualFactors().Size() == 1);
CHECK(map.StateFactors()(0) == Catch::Approx(1.0).epsilon(2.0e-15));
CHECK(map.ResidualFactors()(0) == Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
}
TEST_CASE(
"Generated Normalization Completeness Is SFINAE Safe And Rejects Missing Runtime Metrics",
"[normalization][type][validation]"
) {
using namespace mean_field;
STATIC_CHECK_FALSE(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<int>);
STATIC_CHECK_FALSE(normalization::RegisteredStellarSpecificationNormalization<int>);
STATIC_CHECK_FALSE(normalization::CompleteStellarNormalizationFor<int, SelfDescribingForm>);
STATIC_CHECK(models::ModelSpecification<MissingGeneratedNormalization>);
STATIC_CHECK_FALSE(models::CompleteGeneratedNormalizationFor<MissingGeneratedNormalization>);
STATIC_CHECK_FALSE(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<
MissingGeneratedNormalization>);
STATIC_CHECK_FALSE(normalization::CompilableNormalizationFor<
normalization::PhysicalRieszDiagonal<>,
MissingNormalizationForm>);
STATIC_CHECK_FALSE(normalization::RegisteredStellarSpecificationNormalization<
MissingGeneratedNormalization>);
STATIC_CHECK_FALSE(normalization::CompleteStellarSpecificationNormalizationFor<
MissingGeneratedNormalization,
MissingNormalizationForm>);
STATIC_CHECK(models::ModelSpecification<MalformedGeneratedNormalizationConstraint>);
STATIC_CHECK_FALSE(models::CompleteGeneratedNormalizationFor<
MalformedGeneratedNormalizationConstraint>);
STATIC_CHECK_FALSE(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<
MalformedGeneratedNormalizationConstraint>);
STATIC_CHECK_FALSE(normalization::RegisteredStellarSpecificationNormalization<
MalformedGeneratedNormalizationConstraint>);
// The declaration itself is a valid Riesz law, but runtime stellar
// preparation has no finite-element Gram source for a generated volume
// field. The stronger runtime concept must therefore reject it.
STATIC_CHECK(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<
GeneratedVolumeCoordinateWithoutMetricSource>);
STATIC_CHECK(normalization::CompilableNormalizationFor<
normalization::PhysicalRieszDiagonal<>,
UnpreparedVolumeForm>);
STATIC_CHECK_FALSE(normalization::RegisteredStellarSpecificationNormalization<
GeneratedVolumeCoordinateWithoutMetricSource>);
STATIC_CHECK_FALSE(normalization::CompleteStellarSpecificationNormalizationFor<
GeneratedVolumeCoordinateWithoutMetricSource,
UnpreparedVolumeForm>);
}
TEST_CASE("Characteristic Scale Construction Rejects Invalid Or Overflowing References", "[normalization][validation]") {
using namespace mean_field;
CHECK_THROWS_AS(
normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{0.0}, dimensions::LengthValue{1.0}, 1.0
),
std::invalid_argument
);
CHECK_THROWS_AS(
normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{1.0}, dimensions::LengthValue{-1.0}, 1.0
),
std::invalid_argument
);
CHECK_THROWS_AS(
(normalization::PhysicalRieszDiagonal{dimensions::LengthValue{1.0},
std::numeric_limits<double>::quiet_NaN()}),
std::invalid_argument
);
CHECK_THROWS_AS(
normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{1.0e300}, dimensions::LengthValue{1.0e-200}, 1.0e100
),
std::overflow_error
);
}
TEST_CASE("Diagonal Riesz Maps Reproduce Primal And Dual Norms Across Extreme Metrics", "[normalization][math]") {
const blocks::form_layout<TestForm> layout({3}, {3});
normalization::DiagonalNormalizationBuilder<TestForm> builder(layout);
const mfem::Vector gram = vector({1.0e-20, 4.0, 9.0e20});
constexpr double stateScale = 10.0;
constexpr double residualScale = 0.25;
builder.SetValueBlock<TestValue>(stateScale, gram);
builder.SetResidualBlock<TestResidual>(residualScale, gram);
const normalization::DiagonalNormalization map = std::move(builder).Build();
const mfem::Vector state = vector({3.0e10, -2.0, 4.0e-10});
const mfem::Vector residual = vector({2.0e-10, -3.0, 5.0e10});
double expectedPrimalNormSquared = 0.0;
double expectedDualNormSquared = 0.0;
for (int index = 0; index < gram.Size(); ++index) {
expectedPrimalNormSquared += gram(index) * state(index) * state(index) /
(stateScale * stateScale);
expectedDualNormSquared += residual(index) * residual(index) /
(gram(index) * residualScale * residualScale);
}
CHECK(map.LocalStateNormSquared(state) == Catch::Approx(expectedPrimalNormSquared).epsilon(3.0e-15));
CHECK(map.LocalResidualNormSquared(residual) == Catch::Approx(expectedDualNormSquared).epsilon(3.0e-15));
mfem::Vector normalizedState;
mfem::Vector recoveredState;
mfem::Vector normalizedResidual;
mfem::Vector recoveredResidual;
map.NormalizeState(state, normalizedState);
map.DenormalizeState(normalizedState, recoveredState);
map.NormalizeResidual(residual, normalizedResidual);
map.DenormalizeResidual(normalizedResidual, recoveredResidual);
checkVector(recoveredState, state, 3.0e-15);
checkVector(recoveredResidual, residual, 3.0e-15);
}
TEST_CASE("Hybrid Riesz Rows Replace Missing Volume Metrics With Point Metrics", "[normalization][math]") {
using HybridForm = blocks::block_form<
blocks::type_list<blocks::enthalpy::specific::value>,
blocks::type_list<blocks::enthalpy::specific::residual>>;
const blocks::form_layout<HybridForm> layout({4}, {4});
normalization::DiagonalNormalizationBuilder<HybridForm> builder(layout);
builder.SetValueBlock<blocks::enthalpy::specific::value>(2.0, vector({2.0, 3.0, 5.0, 7.0}));
// Replaced isobaric rows may have zero bulk mass because they are no longer volume weak rows.
const mfem::Vector bulkMetric = vector({4.0, 0.0, 16.0, 0.0});
const std::array<int, 2> pointRows{1, 3};
builder.SetHybridResidualBlock<blocks::enthalpy::specific::residual>(
5.0, bulkMetric, std::span<const int>{pointRows}, 1.0
);
const auto map = std::move(builder).Build();
CHECK(map.ResidualFactors()(0) == Catch::Approx(1.0 / 10.0));
CHECK(map.ResidualFactors()(1) == Catch::Approx(1.0 / 5.0));
CHECK(map.ResidualFactors()(2) == Catch::Approx(1.0 / 20.0));
CHECK(map.ResidualFactors()(3) == Catch::Approx(1.0 / 5.0));
normalization::DiagonalNormalizationBuilder<HybridForm> duplicateRows(layout);
duplicateRows.SetValueGlobal<blocks::enthalpy::specific::value>(1.0);
const std::array<int, 2> duplicates{1, 1};
CHECK_THROWS_AS(
duplicateRows.SetHybridResidualBlock<blocks::enthalpy::specific::residual>(
1.0, vector({1.0, 1.0, 1.0, 1.0}), std::span<const int>{duplicates}
),
std::invalid_argument
);
}
TEST_CASE("Runtime Normalization Assembly Rejects Missing Duplicate And Invalid Data", "[normalization][validation]") {
const blocks::form_layout<TestForm> layout({2}, {2});
normalization::DiagonalNormalizationBuilder<TestForm> missing(layout);
missing.SetValueBlock<TestValue>(1.0, vector({1.0, 1.0}));
CHECK_THROWS_AS(std::move(missing).Build(), std::logic_error);
normalization::DiagonalNormalizationBuilder<TestForm> duplicate(layout);
duplicate.SetValueBlock<TestValue>(1.0, vector({1.0, 1.0}));
CHECK_THROWS_AS(duplicate.SetValueBlock<TestValue>(1.0, vector({1.0, 1.0})), std::logic_error);
normalization::DiagonalNormalizationBuilder<TestForm> zeroMetric(layout);
CHECK_THROWS_AS(zeroMetric.SetValueBlock<TestValue>(1.0, vector({1.0, 0.0})), std::invalid_argument);
normalization::DiagonalNormalizationBuilder<TestForm> wrongSize(layout);
CHECK_THROWS_AS(wrongSize.SetResidualBlock<TestResidual>(1.0, vector({1.0})), std::invalid_argument);
CHECK_THROWS_AS(
normalization::DiagonalNormalization(vector({1.0, std::numeric_limits<double>::infinity()}), vector({1.0})),
std::invalid_argument
);
}
TEST_CASE("Scaled Jacobian And Inverse Implement The Exact Coordinate Change", "[normalization][linear-algebra]") {
const mfem::Vector stateFactors = vector({1.0e-9, 2.0e7});
const mfem::Vector residualFactors = vector({5.0e8, 3.0e-6});
const normalization::DiagonalNormalization map(stateFactors, residualFactors);
// Start from a well-conditioned normalized Jacobian A_hat and form the dimensional
// J = L^{-1} A_hat R^{-1}. Its entries span the physical unit ranges, while L J R
// must recover A_hat rather than an artificially ill-conditioned dense matrix.
constexpr double normalizedMatrix[2][2]{{4.0, 1.0}, {2.0, 3.0}};
constexpr double normalizedInverse[2][2]{{0.3, -0.1}, {-0.2, 0.4}};
mfem::DenseMatrix matrix(2);
mfem::DenseMatrix inverse(2);
for (int row = 0; row < 2; ++row) {
for (int column = 0; column < 2; ++column) {
matrix(row, column) = normalizedMatrix[row][column] * stateFactors(column) /
residualFactors(row);
inverse(row, column) = normalizedInverse[row][column] * residualFactors(column) /
stateFactors(row);
}
}
const DenseOperator physicalJacobian(matrix);
const DenseOperator physicalInverse(inverse);
const normalization::ScaledJacobianOperator scaledJacobian(physicalJacobian, map);
const normalization::ScaledInverseOperator scaledInverse(physicalInverse, map);
const mfem::Vector direction = vector({0.75, -1.25});
mfem::Vector action;
scaledJacobian.Mult(direction, action);
mfem::Vector expected(2);
expected(0) = 4.0 * direction(0) + direction(1);
expected(1) = 2.0 * direction(0) + 3.0 * direction(1);
checkVector(action, expected, 4.0e-15);
mfem::Vector recovered;
scaledInverse.Mult(action, recovered);
checkVector(recovered, direction, 2.0e-13);
}
TEST_CASE("Scaled Preconditioning Routes An Exact Physical Inverse Through FGMRES", "[normalization][solver]") {
const mfem::Vector stateFactors = vector({1.0e-9, 2.0e7});
const mfem::Vector residualFactors = vector({5.0e8, 3.0e-6});
const normalization::DiagonalNormalization map(stateFactors, residualFactors);
constexpr double normalizedMatrix[2][2]{{4.0, 1.0}, {2.0, 3.0}};
constexpr double normalizedInverse[2][2]{{0.3, -0.1}, {-0.2, 0.4}};
mfem::DenseMatrix physicalMatrix(2);
mfem::DenseMatrix physicalInverseMatrix(2);
for (int row = 0; row < 2; ++row) {
for (int column = 0; column < 2; ++column) {
physicalMatrix(row, column) = normalizedMatrix[row][column] * stateFactors(column) /
residualFactors(row);
physicalInverseMatrix(row, column) = normalizedInverse[row][column] * residualFactors(column) /
stateFactors(row);
}
}
const DenseOperator physicalJacobian(physicalMatrix);
const normalization::ScaledJacobianOperator scaledJacobian(physicalJacobian, map);
DenseInverseSolver physicalInverse(physicalInverseMatrix);
normalization::ScaledPreconditioner scaledPreconditioner(
physicalInverse, physicalJacobian, scaledJacobian, map
);
CHECK(physicalInverse.BoundOperator() == &physicalJacobian);
CHECK(&scaledPreconditioner.GetPhysicalJacobian() == &physicalJacobian);
CHECK(&scaledPreconditioner.GetNormalizedJacobian() == &scaledJacobian);
const mfem::Vector rightHandSide = vector({1.5, -0.75});
mfem::Vector directCorrection(2);
scaledPreconditioner.Mult(rightHandSide, directCorrection);
const mfem::Vector expected = vector({0.525, -0.6});
checkVector(directCorrection, expected, 3.0e-13);
mfem::FGMRESSolver krylov(MPI_COMM_WORLD);
krylov.SetRelTol(1.0e-13);
krylov.SetAbsTol(1.0e-15);
krylov.SetMaxIter(4);
krylov.SetKDim(2);
krylov.SetPrintLevel(0);
krylov.SetPreconditioner(scaledPreconditioner);
krylov.SetOperator(scaledJacobian);
mfem::Vector solution(2);
solution = 0.0;
krylov.Mult(rightHandSide, solution);
CHECK(krylov.GetConverged());
CHECK(krylov.GetNumIterations() <= 1);
checkVector(solution, expected, 3.0e-13);
CHECK(physicalInverse.BoundOperator() == &physicalJacobian);
CHECK(physicalInverse.Bindings() >= 2);
CHECK(scaledPreconditioner.GetStatistics().operatorBindings >= 2);
CHECK(scaledPreconditioner.GetStatistics().applications >= 2);
mfem::IdentityOperator differentNormalizedJacobian(2);
CHECK_THROWS_AS(
scaledPreconditioner.SetOperator(differentNormalizedJacobian),
std::invalid_argument
);
mfem::IdentityOperator wrongSize(3);
CHECK_THROWS_AS(scaledPreconditioner.SetOperator(wrongSize), std::invalid_argument);
mfem::Vector wrongCorrection(1);
CHECK_THROWS_AS(scaledPreconditioner.Mult(rightHandSide, wrongCorrection), std::invalid_argument);
}
TEST_CASE("Physical Riesz Scaling Collapses A Forty-Eight-Decade Diagonal Imbalance", "[normalization][numerics]") {
const mfem::Vector stateFactors = vector({1.0e-12, 1.0, 1.0e12});
const mfem::Vector residualFactors = vector({1.0e12, 1.0, 1.0e-12});
const normalization::DiagonalNormalization map(stateFactors, residualFactors);
mfem::DenseMatrix physicalMatrix(3);
physicalMatrix = 0.0;
for (int index = 0; index < 3; ++index) {
physicalMatrix(index, index) = stateFactors(index) / residualFactors(index);
}
CHECK(physicalMatrix(2, 2) / physicalMatrix(0, 0) == Catch::Approx(1.0e48));
const DenseOperator physicalJacobian(physicalMatrix);
const normalization::ScaledJacobianOperator scaledJacobian(physicalJacobian, map);
const mfem::Vector direction = vector({-2.0, 3.5, 0.125});
mfem::Vector action;
scaledJacobian.Mult(direction, action);
checkVector(action, direction, 4.0e-15);
}
TEST_CASE("A Compiled Stellar Problem Prepares Reference Physical Riesz Coordinates", "[normalization][integration]") {
using namespace mean_field;
utils::Args args = test_utils::setup_args();
fem::FEM finiteElements = fem::setup_fem(args.mesh_file, args, 0);
REQUIRE(finiteElements.okay());
constexpr double targetMass = 2.0;
constexpr double referenceRadius = 1.25;
constexpr double gravitationalConstant = 3.0;
const normalization::PhysicalRieszDiagonal policy{
dimensions::LengthValue{referenceRadius}, gravitationalConstant
};
const auto discretization = equilibrium::makeStellarDiscretization(finiteElements, policy);
auto problem = equilibrium::discretize(
model::StellarModel(
eos::Polytrope({.n = 3.0, .K = 0.25}),
surface::Isobaric({.Psurf = dimensions::PressureValue{0.0}}),
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{targetMass}}),
constraint::FixedCentralDensity({.RhoC = dimensions::DensityValue{1.0}})
),
discretization
);
using ProblemType = std::remove_cvref_t<decltype(problem)>;
using Form = typename ProblemType::FormType;
using ModelType = std::remove_cvref_t<decltype(problem.GetStellarModel())>;
STATIC_CHECK(SupportsModelDerivedStellarScales<ModelType>);
STATIC_CHECK_FALSE(SupportsModelDerivedStellarScales<ModelWithoutFixedTotalMass>);
STATIC_CHECK(std::same_as<
typename ProblemType::NormalizationPrescriptionType,
std::remove_cvref_t<decltype(policy)>>);
CHECK(problem.GetNormalizationPrescription().referenceRadius() == dimensions::LengthValue{referenceRadius});
const normalization::DiagonalNormalization map = normalization::prepareNormalization(problem);
REQUIRE(map.StateSize() == problem.StateSize());
REQUIRE(map.ResidualSize() == problem.EquationSize());
for (int index = 0; index < map.StateSize(); ++index) {
CHECK(std::isfinite(map.StateFactors()(index)));
CHECK(map.StateFactors()(index) > 0.0);
}
for (int index = 0; index < map.ResidualSize(); ++index) {
CHECK(std::isfinite(map.ResidualFactors()(index)));
CHECK(map.ResidualFactors()(index) > 0.0);
}
const auto scales = normalization::deriveStellarCharacteristicScales(policy, problem.GetStellarModel());
const auto &layout = problem.GetManifest().layout();
constexpr int massValueBlock = blocks::type_index_v<
blocks::fixed_total_mass::mass_normalization::value,
typename Form::value_blocks>;
constexpr int massResidualBlock = blocks::type_index_v<
blocks::fixed_total_mass::mass_normalization::residual,
typename Form::residual_blocks>;
constexpr int phaseValueBlock = blocks::type_index_v<
blocks::fixed_central_density::central_value::value,
typename Form::value_blocks>;
constexpr int phaseResidualBlock = blocks::type_index_v<
blocks::fixed_central_density::central_value::residual,
typename Form::residual_blocks>;
constexpr int enthalpyResidualBlock = blocks::type_index_v<
blocks::enthalpy::specific::residual,
typename Form::residual_blocks>;
CHECK(map.StateFactors()(layout.value_offsets()[massValueBlock]) ==
Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
CHECK(map.ResidualFactors()(layout.residual_offsets()[massResidualBlock]) ==
Catch::Approx(1.0 / targetMass).epsilon(2.0e-15));
CHECK(map.StateFactors()(layout.value_offsets()[phaseValueBlock]) ==
Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
CHECK(map.ResidualFactors()(layout.residual_offsets()[phaseResidualBlock]) ==
Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
const auto &surfaceRows = problem.GetPressureSurfaceRows().reduced_dofs();
REQUIRE(surfaceRows.Size() > 0);
for (const int row : surfaceRows) {
const int rootRow = layout.residual_offsets()[enthalpyResidualBlock] + row;
CHECK(map.ResidualFactors()(rootRow) ==
Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
}
mfem::Vector physicalState(problem.StateSize());
for (int index = 0; index < physicalState.Size(); ++index) {
physicalState(index) = std::sin(0.37 * static_cast<double>(index + 1));
}
mfem::Vector normalizedState;
mfem::Vector recoveredState;
map.NormalizeState(physicalState, normalizedState);
map.DenormalizeState(normalizedState, recoveredState);
checkVector(recoveredState, physicalState, 4.0e-15);
const normalization::ScaledJacobianOperator scaledJacobian(problem.GetLinearizationOperator(), map);
CHECK(scaledJacobian.Width() == problem.StateSize());
CHECK(scaledJacobian.Height() == problem.EquationSize());
// The existing provisional structure preconditioner remains available for this distinct problem type.
const auto structureBlock = preconditioning::stellarStructureBlock(problem);
STATIC_CHECK(preconditioning::PreconditionerComponent<std::remove_cvref_t<decltype(structureBlock)>>);
}

228
tests/normalization/plan.cpp Normal file
View File

@@ -0,0 +1,228 @@
#include <concepts>
#include <type_traits>
#include <utility>
#include <catch2/catch_test_macros.hpp>
import mean_field;
namespace {
namespace blocks = mean_field::utils::blocks;
namespace normalization = mean_field::normalization;
using PhysicalForm = blocks::surface_deformed_stellar_equilibrium_form;
using PhaseForm = blocks::central_density_bordered_stellar_equilibrium_form;
using PhysicalPlan = normalization::PhysicalRieszNormalizationPlanFor<PhysicalForm>;
using PhasePlan = normalization::PhysicalRieszNormalizationPlanFor<PhaseForm>;
struct ValueA final : blocks::value_block_base { };
struct ValueB final : blocks::value_block_base { };
struct ResidualA final : blocks::residual_block_base { };
struct ResidualB final : blocks::residual_block_base { };
struct ForeignValue final : blocks::value_block_base { };
struct ForeignResidual final : blocks::residual_block_base { };
using SmallForm = blocks::block_form<
blocks::type_list<ValueA, ValueB>,
blocks::type_list<ResidualA, ResidualB>>;
using ValueAIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::value,
blocks::type_list<ValueA>,
normalization::IdentityCoordinate>;
using ValueBIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::value,
blocks::type_list<ValueB>,
normalization::IdentityCoordinate>;
using ResidualAIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::residual,
blocks::type_list<ResidualA>,
normalization::IdentityCoordinate>;
using ResidualBIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::residual,
blocks::type_list<ResidualB>,
normalization::IdentityCoordinate>;
using ForeignIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::value,
blocks::type_list<ForeignValue>,
normalization::IdentityCoordinate>;
using ForeignResidualIdentity = normalization::CoordinateComponent<
normalization::CoordinateKind::residual,
blocks::type_list<ForeignResidual>,
normalization::IdentityCoordinate>;
using CompleteSmallPlan = normalization::NormalizationPlan<
ValueAIdentity,
ValueBIdentity,
ResidualAIdentity,
ResidualBIdentity>;
using MissingSmallPlan = normalization::NormalizationPlan<
ValueAIdentity,
ResidualAIdentity,
ResidualBIdentity>;
using DuplicateSmallPlan = normalization::NormalizationPlan<
ValueAIdentity,
ValueAIdentity,
ValueBIdentity,
ResidualAIdentity,
ResidualBIdentity>;
using ForeignSmallPlan = normalization::NormalizationPlan<
ValueAIdentity,
ValueBIdentity,
ForeignIdentity,
ResidualAIdentity,
ResidualBIdentity,
ForeignResidualIdentity>;
struct MalformedComponent final {
using Blocks = blocks::type_list<ValueA>;
using Method = normalization::IdentityCoordinate;
};
struct IncoherentComponent final {
using Blocks = blocks::type_list<ValueA>;
using Method = normalization::IdentityCoordinate;
using ValueBlocks = blocks::type_list<ValueB>;
using ResidualBlocks = blocks::type_list<>;
static constexpr auto kind = normalization::CoordinateKind::value;
};
using WrongDensityTopology = normalization::CoordinateComponent<
normalization::CoordinateKind::value,
blocks::type_list<blocks::density::mass::value>,
normalization::PhysicalRieszCoordinate<
normalization::RieszTopology::vector_volume_l2,
normalization::PhysicalScaleKind::density>>;
struct FutureInvariantValue final : blocks::value_block_base { };
struct FutureInvariantResidual final : blocks::residual_block_base { };
using UnregisteredFutureForm = blocks::block_form<
blocks::type_list<FutureInvariantValue>,
blocks::type_list<FutureInvariantResidual>>;
using BaseModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
mean_field::eos::Polytrope,
mean_field::surface::Isobaric,
mean_field::integral::FixedTotalMass>>;
using RieszPolicy = normalization::PhysicalRieszDiagonal<>;
using RieszDiscretization = mean_field::equilibrium::StellarDiscretizationFor<RieszPolicy>;
using BaselineProblem = mean_field::equilibrium::StellarEquilibriumProblem<BaseModel>;
using RieszProblem = mean_field::equilibrium::StellarEquilibriumProblem<BaseModel, RieszDiscretization>;
using AngularModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
mean_field::eos::Polytrope,
mean_field::surface::Isobaric,
mean_field::integral::FixedTotalMass,
mean_field::integral::FixedAngularMomentum>>;
using AngularForm = mean_field::operators::CompiledStellarEquilibriumForm<AngularModel>;
template <typename Mapper>
concept CanMakeRieszDiscretization = requires(
mean_field::fem::FEM &finiteElements,
Mapper &&mapper,
RieszPolicy policy
) {
mean_field::equilibrium::makeStellarDiscretization(
finiteElements,
std::forward<Mapper>(mapper),
policy
);
};
} // namespace
TEST_CASE("Normalization Plans Prove Exact Ownership Of Every Compiled Coordinate", "[normalization][type]") {
STATIC_CHECK(normalization::NormalizationPlanType<PhysicalPlan>);
STATIC_CHECK(normalization::CompleteNormalizationFor<PhysicalPlan, PhysicalForm>);
STATIC_CHECK(normalization::CompleteNormalizationFor<PhasePlan, PhaseForm>);
STATIC_CHECK(normalization::CompilableNormalizationFor<normalization::Unnormalized, PhysicalForm>);
STATIC_CHECK(normalization::CompilableNormalizationFor<RieszPolicy, PhysicalForm>);
STATIC_CHECK(normalization::CompilableNormalizationFor<RieszPolicy, PhaseForm>);
STATIC_CHECK(normalization::CompilableNormalizationFor<RieszPolicy, AngularForm>);
STATIC_CHECK(normalization::StellarSpecificationNormalizationContribution<
mean_field::integral::FixedAngularMomentum>::registered);
STATIC_CHECK(normalization::CompleteNormalizationFor<CompleteSmallPlan, SmallForm>);
STATIC_CHECK_FALSE(normalization::CompleteNormalizationFor<MissingSmallPlan, SmallForm>);
STATIC_CHECK_FALSE(normalization::CompleteNormalizationFor<DuplicateSmallPlan, SmallForm>);
STATIC_CHECK_FALSE(normalization::CompleteNormalizationFor<ForeignSmallPlan, SmallForm>);
using Missing = normalization::NormalizationCoverage<SmallForm, MissingSmallPlan>;
using Duplicate = normalization::NormalizationCoverage<SmallForm, DuplicateSmallPlan>;
using Foreign = normalization::NormalizationCoverage<SmallForm, ForeignSmallPlan>;
STATIC_CHECK(Missing::MissingValueBlocks::size == 1);
STATIC_CHECK(blocks::contains_type_v<ValueB, typename Missing::MissingValueBlocks>);
STATIC_CHECK(Duplicate::RepeatedValueBlocks::size == 1);
STATIC_CHECK(blocks::contains_type_v<ValueA, typename Duplicate::RepeatedValueBlocks>);
STATIC_CHECK(Foreign::UnexpectedValueBlocks::size == 1);
STATIC_CHECK(Foreign::UnexpectedResidualBlocks::size == 1);
}
TEST_CASE("Physical Riesz Methods Reject Incompatible Or Unregistered Field Topologies", "[normalization][type]") {
STATIC_CHECK_FALSE(normalization::NormalizationComponent<MalformedComponent>);
STATIC_CHECK_FALSE(normalization::NormalizationComponent<IncoherentComponent>);
STATIC_CHECK_FALSE(normalization::NormalizationComponent<WrongDensityTopology>);
STATIC_CHECK_FALSE(normalization::CompilableNormalizationFor<RieszPolicy, UnregisteredFutureForm>);
STATIC_CHECK(normalization::CompilableNormalizationFor<normalization::Unnormalized, UnregisteredFutureForm>);
using Density = normalization::PhysicalRieszBlockTraits<blocks::density::mass::value>;
using Gravity = normalization::PhysicalRieszBlockTraits<blocks::gravity::gradient::value>;
using Surface = normalization::PhysicalRieszBlockTraits<blocks::surface_deformation::parameters::value>;
using EnthalpyResidual = normalization::PhysicalRieszBlockTraits<blocks::enthalpy::specific::residual>;
using MassResidual = normalization::PhysicalRieszBlockTraits<
blocks::fixed_total_mass::mass_normalization::residual>;
STATIC_CHECK(Density::Method::topology == normalization::RieszTopology::scalar_volume_l2);
STATIC_CHECK(Gravity::Method::topology == normalization::RieszTopology::vector_volume_l2);
STATIC_CHECK(Surface::Method::topology == normalization::RieszTopology::scalar_boundary_l2);
STATIC_CHECK(
EnthalpyResidual::Method::topology == normalization::RieszTopology::hybrid_scalar_volume_point_rows
);
STATIC_CHECK(MassResidual::Method::topology == normalization::RieszTopology::global_scalar);
STATIC_CHECK(MassResidual::Method::scale == normalization::PhysicalScaleKind::mass);
}
TEST_CASE("Normalization Is Part Of The Compile-Time Discretization And Problem Type", "[normalization][type]") {
STATIC_CHECK(mean_field::equilibrium::StellarDiscretizationType<RieszDiscretization>);
STATIC_CHECK_FALSE(std::same_as<RieszDiscretization, mean_field::equilibrium::StellarDiscretization>);
STATIC_CHECK_FALSE(std::same_as<RieszProblem, BaselineProblem>);
STATIC_CHECK(std::same_as<typename BaselineProblem::NormalizationPrescriptionType, normalization::Unnormalized>);
STATIC_CHECK(std::same_as<typename RieszProblem::NormalizationPrescriptionType, RieszPolicy>);
STATIC_CHECK(mean_field::equilibrium::DiscretizedStellarEquilibriumProblem<RieszProblem>);
STATIC_CHECK(std::constructible_from<
RieszDiscretization,
mean_field::fem::FEM &,
const mean_field::mapping::DomainMapper &,
RieszPolicy>);
STATIC_CHECK_FALSE(std::constructible_from<
RieszDiscretization,
mean_field::fem::FEM &,
mean_field::mapping::DomainMapper &&,
RieszPolicy>);
STATIC_CHECK_FALSE(std::constructible_from<
RieszDiscretization,
mean_field::fem::FEM &,
const mean_field::mapping::DomainMapper &&,
RieszPolicy>);
STATIC_CHECK(std::constructible_from<
mean_field::equilibrium::StellarDiscretization,
mean_field::fem::FEM &,
const mean_field::mapping::DomainMapper &>);
STATIC_CHECK_FALSE(std::constructible_from<
mean_field::equilibrium::StellarDiscretization,
mean_field::fem::FEM &,
mean_field::mapping::DomainMapper &&>);
STATIC_CHECK_FALSE(std::constructible_from<
mean_field::equilibrium::StellarDiscretization,
mean_field::fem::FEM &,
const mean_field::mapping::DomainMapper &&>);
STATIC_CHECK(CanMakeRieszDiscretization<
mean_field::mapping::DomainMapper &>);
STATIC_CHECK_FALSE(CanMakeRieszDiscretization<
mean_field::mapping::DomainMapper>);
STATIC_CHECK_FALSE(CanMakeRieszDiscretization<
const mean_field::mapping::DomainMapper>);
using SmallLayout = blocks::form_layout<SmallForm>;
using SmallBuilder = normalization::DiagonalNormalizationBuilder<SmallForm>;
STATIC_CHECK(std::constructible_from<SmallBuilder, const SmallLayout &>);
STATIC_CHECK_FALSE(std::constructible_from<SmallBuilder, SmallLayout &&>);
STATIC_CHECK_FALSE(std::constructible_from<SmallBuilder, const SmallLayout &&>);
}

1187
tests/normalization/stellar_equilibrium.cpp Normal file
View File

File diff suppressed because it is too large Load Diff