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

feat(newton): first newton solver implementation

Browse Source
This commit is contained in:
Emily Boudreaux
2026-09-08 06:36:39 -04:00
parent 76818f2f82
commit b3c04d507a
98 changed files with 20397 additions and 11040 deletions
Download Patch File Download Diff File Expand all files Collapse all files

559
tests/normalization/physical_riesz.cpp
View File

@@ -15,34 +15,28 @@ import mean_field;
import test_helpers;
namespace {
namespace blocks = mean_field::utils::blocks;
namespace blocks = mean_field::utils::blocks;
namespace normalization = mean_field::normalization;
namespace models = mean_field::models;
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>;
};
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 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>;
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:
@@ -98,9 +92,7 @@ namespace {
"NormalizationMockVolumeCoordinate",
models::DependsOn<blocks::density::mass::value>,
models::Affects<blocks::enthalpy::specific::residual>,
models::GeneratedNormalization<
VolumeSpecificEnergyNormalization,
GlobalSpecificEnergyNormalization>>;
models::GeneratedNormalization<VolumeSpecificEnergyNormalization, GlobalSpecificEnergyNormalization>>;
explicit constexpr GeneratedVolumeCoordinateWithoutMetricSource(const Parameters parameters) noexcept
: m_target(parameters.target) {
@@ -134,39 +126,36 @@ namespace {
};
template <typename Specification>
using GeneratedValueBlock = blocks::generated_value_block<
models::PhysicalCoordinateFor<Specification>>;
using GeneratedValueBlock = blocks::generated_value_block<models::PhysicalCoordinateFor<Specification>>;
template <typename Specification>
using GeneratedMultiplierBlock = blocks::generated_value_block<
models::MultiplierFor<Specification>>;
using GeneratedMultiplierBlock = blocks::generated_value_block<models::MultiplierFor<Specification>>;
template <typename Specification>
using GeneratedResidualBlock = blocks::generated_residual_block<
models::ResidualFor<Specification>>;
using GeneratedResidualBlock = blocks::generated_residual_block<models::ResidualFor<Specification>>;
using SelfDescribingValue = GeneratedValueBlock<SelfDescribingMagneticSpecificEnergy>;
using SelfDescribingValue = GeneratedValueBlock<SelfDescribingMagneticSpecificEnergy>;
using SelfDescribingResidual = GeneratedResidualBlock<SelfDescribingMagneticSpecificEnergy>;
using SelfDescribingForm = blocks::block_form<
blocks::type_list<SelfDescribingValue>,
blocks::type_list<SelfDescribingResidual>>;
using SelfDescribingForm =
blocks::block_form<blocks::type_list<SelfDescribingValue>, blocks::type_list<SelfDescribingResidual>>;
using MissingValue = GeneratedMultiplierBlock<MissingGeneratedNormalization>;
using MissingValue = GeneratedMultiplierBlock<MissingGeneratedNormalization>;
using MissingResidual = GeneratedResidualBlock<MissingGeneratedNormalization>;
using MissingNormalizationForm = blocks::block_form<
blocks::type_list<MissingValue>,
blocks::type_list<MissingResidual>>;
using MissingNormalizationForm =
blocks::block_form<blocks::type_list<MissingValue>, blocks::type_list<MissingResidual>>;
using UnpreparedVolumeValue = GeneratedValueBlock<GeneratedVolumeCoordinateWithoutMetricSource>;
using UnpreparedVolumeValue = GeneratedValueBlock<GeneratedVolumeCoordinateWithoutMetricSource>;
using UnpreparedVolumeResidual = GeneratedResidualBlock<GeneratedVolumeCoordinateWithoutMetricSource>;
using UnpreparedVolumeForm = blocks::block_form<
blocks::type_list<UnpreparedVolumeValue>,
blocks::type_list<UnpreparedVolumeResidual>>;
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()),
: mfem::Operator(
matrix.Height(),
matrix.Width()
),
m_matrix(matrix) {
}
@@ -184,7 +173,10 @@ namespace {
class DenseInverseSolver final : public mfem::Solver {
public:
explicit DenseInverseSolver(const mfem::DenseMatrix &inverse)
: mfem::Solver(inverse.Height(), inverse.Width()),
: mfem::Solver(
inverse.Height(),
inverse.Width()
),
m_inverse(inverse) {
}
@@ -247,75 +239,54 @@ TEST_CASE(
) {
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::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::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 &&>);
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]") {
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 mass = 7.0;
constexpr double radius = 3.0;
constexpr double gravity = 5.0;
const auto scales = normalization::deriveStellarCharacteristicScales(
const auto scales = normalization::deriveStellarCharacteristicScales(
dimensions::MassValue{mass}, dimensions::LengthValue{radius}, gravity
);
@@ -332,66 +303,87 @@ TEST_CASE("Characteristic Stellar Scales Satisfy Gravity Virial And Rotation Ide
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));
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]") {
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;
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
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));
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]") {
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
);
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);
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);
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(
@@ -399,39 +391,40 @@ TEST_CASE(
"[normalization][type][extension]"
) {
using namespace mean_field;
using ValueTraits = normalization::PhysicalRieszBlockTraits<SelfDescribingValue>;
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(
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 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);
normalization::StellarSpecificationNormalizationContribution<SelfDescribingMagneticSpecificEnergy>::Apply(
builder, scales
);
const normalization::DiagonalNormalization map = std::move(builder).Build();
REQUIRE(map.StateFactors().Size() == 1);
@@ -452,47 +445,51 @@ TEST_CASE(
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_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>);
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>);
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]") {
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
),
normalization::deriveStellarCharacteristicScales(dimensions::MassValue{0.0}, dimensions::LengthValue{1.0}, 1.0),
std::invalid_argument
);
CHECK_THROWS_AS(
@@ -502,8 +499,7 @@ TEST_CASE("Characteristic Scale Construction Rejects Invalid Or Overflowing Refe
std::invalid_argument
);
CHECK_THROWS_AS(
(normalization::PhysicalRieszDiagonal{dimensions::LengthValue{1.0},
std::numeric_limits<double>::quiet_NaN()}),
(normalization::PhysicalRieszDiagonal{dimensions::LengthValue{1.0}, std::numeric_limits<double>::quiet_NaN()}),
std::invalid_argument
);
CHECK_THROWS_AS(
@@ -514,25 +510,26 @@ TEST_CASE("Characteristic Scale Construction Rejects Invalid Or Overflowing Refe
);
}
TEST_CASE("Diagonal Riesz Maps Reproduce Primal And Dual Norms Across Extreme Metrics", "[normalization][math]") {
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;
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;
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);
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));
@@ -549,10 +546,12 @@ TEST_CASE("Diagonal Riesz Maps Reproduce Primal And Dual Norms Across Extreme Me
checkVector(recoveredResidual, residual, 3.0e-15);
}
TEST_CASE("Hybrid Riesz Rows Replace Missing Volume Metrics With Point Metrics", "[normalization][math]") {
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>>;
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}));
@@ -580,7 +579,10 @@ TEST_CASE("Hybrid Riesz Rows Replace Missing Volume Metrics With Point Metrics",
);
}
TEST_CASE("Runtime Normalization Assembly Rejects Missing Duplicate And Invalid Data", "[normalization][validation]") {
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);
@@ -603,8 +605,11 @@ TEST_CASE("Runtime Normalization Assembly Rejects Missing Duplicate And Invalid
);
}
TEST_CASE("Scaled Jacobian And Inverse Implement The Exact Coordinate Change", "[normalization][linear-algebra]") {
const mfem::Vector stateFactors = vector({1.0e-9, 2.0e7});
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);
@@ -617,10 +622,8 @@ TEST_CASE("Scaled Jacobian And Inverse Implement The Exact Coordinate Change", "
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);
matrix(row, column) = normalizedMatrix[row][column] * stateFactors(column) / residualFactors(row);
inverse(row, column) = normalizedInverse[row][column] * residualFactors(column) / stateFactors(row);
}
}
const DenseOperator physicalJacobian(matrix);
@@ -641,8 +644,11 @@ TEST_CASE("Scaled Jacobian And Inverse Implement The Exact Coordinate Change", "
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});
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);
@@ -652,19 +658,16 @@ TEST_CASE("Scaled Preconditioning Routes An Exact Physical Inverse Through FGMRE
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);
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
);
normalization::ScaledPreconditioner scaledPreconditioner(physicalInverse, physicalJacobian, scaledJacobian, map);
CHECK(physicalInverse.BoundOperator() == &physicalJacobian);
CHECK(&scaledPreconditioner.GetPhysicalJacobian() == &physicalJacobian);
@@ -697,18 +700,18 @@ TEST_CASE("Scaled Preconditioning Routes An Exact Physical Inverse Through FGMRE
CHECK(scaledPreconditioner.GetStatistics().applications >= 2);
mfem::IdentityOperator differentNormalizedJacobian(2);
CHECK_THROWS_AS(
scaledPreconditioner.SetOperator(differentNormalizedJacobian),
std::invalid_argument
);
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});
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);
@@ -727,38 +730,38 @@ TEST_CASE("Physical Riesz Scaling Collapses A Forty-Eight-Decade Diagonal Imbala
checkVector(action, direction, 4.0e-15);
}
TEST_CASE("A Compiled Stellar Problem Prepares Reference Physical Riesz Coordinates", "[normalization][integration]") {
TEST_CASE(
"A Compiled Stellar Problem Prepares Reference Physical Riesz Coordinates",
"[normalization][integration]"
) {
using namespace mean_field;
utils::Args args = test_utils::setup_args();
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 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(
const normalization::PhysicalRieszDiagonal policy{dimensions::LengthValue{referenceRadius}, gravitationalConstant};
auto discretization = equilibrium::makeStellarDiscretization(std::move(finiteElements), policy);
auto problem = equilibrium::discretize(
model::StellarModel(
eos::Polytrope({.n = 3.0, .K = 0.25}),
surface::Isobaric({.Psurf = dimensions::PressureValue{0.0}}),
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
std::move(discretization)
);
using ProblemType = std::remove_cvref_t<decltype(problem)>;
using Form = typename ProblemType::FormType;
using ModelType = std::remove_cvref_t<decltype(problem.GetStellarModel())>;
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)>>);
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);
@@ -773,39 +776,41 @@ TEST_CASE("A Compiled Stellar Problem Prepares Reference Physical Riesz Coordina
CHECK(map.ResidualFactors()(index) > 0.0);
}
const auto scales = normalization::deriveStellarCharacteristicScales(policy, problem.GetStellarModel());
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>;
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));
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));
CHECK(map.ResidualFactors()(rootRow) == Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15));
}
mfem::Vector physicalState(problem.StateSize());