tboudreaux/MeanField
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b3c04d507a1d7bc321ba6edd9dde33f6713345c1
MeanField/tests/extensions/fixed_magnetic_specific_energy.cpp

1913 lines
93 KiB
C++
Raw Blame History

#include <algorithm>
#include <cmath>
#include <concepts>
#include <limits>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <mfem.hpp>
import mean_field;
import test_helpers;
/*
* This file deliberately implements complete third-party scalar constraints
* rather than adding library builtins. It is an executable example of the
* intended physics extension boundary: each declaration and exact
* residual/Jacobian provider is written once and is then folded into every
* model-level operator. The generic preconditioner projects those same
* providers into its generated border blocks; extension authors do not write
* a second, potentially inconsistent border action. Prepared extension physics
* receives only its exact specification, the state and residual blocks it
* declared, and any narrowly typed astronomy service admitted by that
* declaration. Backend FEM, model, dependency, and core objects remain absent
* from the author-facing protocol.
*/
namespace magnetic_specific_energy_extension_test {
namespace blocks = mean_field::utils::blocks;
namespace preconditioning = mean_field::preconditioning;
class FixedMagneticSpecificEnergy;
class FixedCoreThermalBalance;
struct MagneticAmplitudeTerm final {
using value =
blocks::generated_value_block<mean_field::models::PhysicalCoordinateFor<FixedMagneticSpecificEnergy>>;
using residual = blocks::generated_residual_block<mean_field::models::ResidualFor<FixedMagneticSpecificEnergy>>;
};
inline constexpr MagneticAmplitudeTerm magneticAmplitudeTerm{};
struct CoreThermalMultiplierTerm final {
using value = blocks::generated_value_block<mean_field::models::MultiplierFor<FixedCoreThermalBalance>>;
using residual = blocks::generated_residual_block<mean_field::models::ResidualFor<FixedCoreThermalBalance>>;
};
inline constexpr CoreThermalMultiplierTerm coreThermalMultiplierTerm{};
class PreparedMagneticSpecificEnergy;
class PreparedCoreThermalBalance;
inline constexpr double thermalMagneticCoupling = 0.125;
inline constexpr double magneticThermalFeedback = 0.2;
inline constexpr double thermalMassCoupling = 0.35;
/*
* Toy magnetic closure used by this integration test:
*
* e_B(h_0, a_B) = 1/2 a_B^2 h_0,
* R_B = e_B - e_B,target,
* R_h += e_B,target a_B.
*
* a_B is a dimensionless physical amplitude. This makes the invariant
* genuinely nonlinear and exercises all three generated-border blocks:
* structure-to-border, border-to-structure, and border-to-border.
*/
class FixedMagneticSpecificEnergy final {
public:
struct Parameters final {
mean_field::dimensions::SpecificEnergyValue target;
};
using TargetValue = mean_field::dimensions::SpecificEnergyValue;
using ModelDefinition = mean_field::integral::FixedScalarWithPhysicalCoordinate<
FixedMagneticSpecificEnergy,
"FixedMagneticSpecificEnergy",
mean_field::stellar::
Reads<mean_field::stellar::state::SpecificEnthalpy, mean_field::stellar::state::OwnGeneratedCoordinate>,
mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
mean_field::stellar::ScalarConstraint<
mean_field::dimensions::quantity::SpecificEnergy,
mean_field::dimensions::quantity::Dimensionless,
mean_field::dimensions::quantity::SpecificEnergy,
"fixed_magnetic_specific_energy.amplitude",
"a_B",
"fixed_magnetic_specific_energy.residual",
"R_EB">>;
using EquilibriumPhysics =
mean_field::operators::LocalSpecificationEquilibriumPhysics<PreparedMagneticSpecificEnergy>;
explicit FixedMagneticSpecificEnergy(const Parameters parameters) : m_target(parameters.target) {
if (!std::isfinite(m_target.value()) || m_target.value() <= 0.0) {
throw std::invalid_argument("The target magnetic specific energy must be finite and positive.");
}
}
[[nodiscard]] TargetValue target() const noexcept {
return m_target;
}
private:
TargetValue m_target;
};
/*
* A second scalar closure used to audit a pack containing more than one
* third-party nested runtime and direct coupling between their generated
* coordinates and equations:
*
* x_T = lambda_T / h_ref,
* R_T = P_* [h_0/h_ref + 1/4 x_T^2 + gamma a_B x_T - 1
* + delta (integral rho dV / M_ref - 1)],
* R_B += eta a_B lambda_T,
* R_h += lambda_T.
*
* lambda_T has specific-energy units, while R_T has pressure units. The
* explicit h_ref and M_ref keep every ratio dimensionless, and the
* quadratic term makes the multiplier's own diagonal border action state
* dependent. The density term is evaluated as a global finite-element
* physical-volume integral. The two cross terms exercise
* GeneratedCoordinateOf and ConstraintOf numerically: the thermal package
* contributes to the magnetic row without either package knowing a root
* offset or a constraint-pack ordering.
*/
class FixedCoreThermalBalance final {
public:
struct Parameters final {
mean_field::dimensions::PressureValue target;
mean_field::dimensions::SpecificEnthalpyValue referenceSpecificEnthalpy;
mean_field::dimensions::MassValue referenceMass;
};
using TargetValue = mean_field::dimensions::PressureValue;
using ModelDefinition = mean_field::integral::FixedScalarWithMultiplier<
FixedCoreThermalBalance,
"FixedCoreThermalBalance",
mean_field::stellar::Reads<
mean_field::stellar::state::Density,
mean_field::stellar::state::SurfaceShape,
mean_field::stellar::state::SpecificEnthalpy,
mean_field::stellar::state::OwnGeneratedCoordinate,
mean_field::stellar::state::GeneratedCoordinateOf<FixedMagneticSpecificEnergy>>,
mean_field::stellar::Changes<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>>,
mean_field::stellar::ScalarConstraint<
mean_field::dimensions::quantity::Pressure,
mean_field::dimensions::quantity::SpecificEnergy,
mean_field::dimensions::quantity::Pressure,
"fixed_core_thermal_balance.multiplier",
"lambda_T",
"fixed_core_thermal_balance.residual",
"R_T">>;
using EquilibriumPhysics =
mean_field::operators::LocalSpecificationEquilibriumPhysics<PreparedCoreThermalBalance>;
explicit FixedCoreThermalBalance(const Parameters parameters)
: m_target(parameters.target),
m_referenceSpecificEnthalpy(parameters.referenceSpecificEnthalpy),
m_referenceMass(parameters.referenceMass) {
if (!std::isfinite(m_target.value()) || m_target.value() <= 0.0) {
throw std::invalid_argument("The target core thermal balance must be finite and positive.");
}
if (!std::isfinite(m_referenceSpecificEnthalpy.value()) || m_referenceSpecificEnthalpy.value() <= 0.0) {
throw std::invalid_argument("The core thermal balance reference enthalpy must be finite and positive.");
}
if (!std::isfinite(m_referenceMass.value()) || m_referenceMass.value() <= 0.0) {
throw std::invalid_argument("The core thermal balance reference mass must be finite and positive.");
}
}
[[nodiscard]] TargetValue target() const noexcept {
return m_target;
}
[[nodiscard]] mean_field::dimensions::SpecificEnthalpyValue referenceSpecificEnthalpy() const noexcept {
return m_referenceSpecificEnthalpy;
}
[[nodiscard]] mean_field::dimensions::MassValue referenceMass() const noexcept {
return m_referenceMass;
}
private:
TargetValue m_target;
mean_field::dimensions::SpecificEnthalpyValue m_referenceSpecificEnthalpy;
mean_field::dimensions::MassValue m_referenceMass;
};
struct MagneticSpecificEnergyPreparationReport final {
bool stateChanged{true};
};
struct CoreThermalBalancePreparationReport final {
bool stateChanged{true};
};
class PreparedMagneticSpecificEnergy final {
public:
using Report = MagneticSpecificEnergyPreparationReport;
explicit PreparedMagneticSpecificEnergy(const FixedMagneticSpecificEnergy &specification) noexcept
: m_target(specification.target().value()) {
}
template <typename StateView> [[nodiscard]] Report PrepareAfterPhysical(const StateView &state) {
const auto enthalpy = state.specificEnthalpy();
const auto amplitude = state.generatedCoordinate();
if (enthalpy.Size() == 0 || amplitude.Size() != 1 || !std::isfinite(enthalpy(0)) ||
!std::isfinite(amplitude(0))) {
throw std::invalid_argument(
"Magnetic-specific-energy preparation requires finite enthalpy and amplitude."
);
}
const bool changed = !m_isPrepared || enthalpy(0) != m_referenceEnthalpy || amplitude(0) != m_amplitude;
m_referenceEnthalpy = enthalpy(0);
m_amplitude = amplitude(0);
m_invariantResidual = 0.5 * m_amplitude * m_amplitude * m_referenceEnthalpy - m_target;
m_hydrostaticContribution = m_target * m_amplitude;
m_isPrepared = true;
return {.stateChanged = changed};
}
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::OwnConstraint,
Row &row
) const {
return row.add(m_invariantResidual);
}
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::HydrostaticBalance,
Row &row
) const {
return row.add(m_hydrostaticContribution);
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::SpecificEnthalpy>,
const Direction &direction,
Row &row
) const {
const auto enthalpyDirection = direction.specificEnthalpy();
return row.add(0.5 * m_amplitude * m_amplitude * enthalpyDirection(0));
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::OwnGeneratedCoordinate>,
const Direction &direction,
Row &row
) const {
const auto amplitudeDirection = direction.generatedCoordinate();
return row.add(m_amplitude * m_referenceEnthalpy * amplitudeDirection(0));
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::SpecificEnthalpy>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::OwnGeneratedCoordinate>,
const Direction &direction,
Row &row
) const {
const auto amplitudeDirection = direction.generatedCoordinate();
return row.add(m_target * amplitudeDirection(0));
}
[[nodiscard]] bool IsPrepared() const noexcept {
return m_isPrepared;
}
[[nodiscard]] double target() const noexcept {
return m_target;
}
[[nodiscard]] double referenceEnthalpy() const noexcept {
return m_referenceEnthalpy;
}
[[nodiscard]] double amplitude() const noexcept {
return m_amplitude;
}
private:
double m_target{0.0};
double m_referenceEnthalpy{0.0};
double m_amplitude{0.0};
double m_invariantResidual{0.0};
double m_hydrostaticContribution{0.0};
bool m_isPrepared{false};
};
class PreparedCoreThermalBalance final {
public:
using Report = CoreThermalBalancePreparationReport;
using IntegralContext = mean_field::stellar::DensityVolumeIntegralContext<FixedCoreThermalBalance>;
PreparedCoreThermalBalance(
const FixedCoreThermalBalance &specification,
IntegralContext integralContext
) noexcept
: m_targetPressure(specification.target().value()),
m_referenceEnthalpy(specification.referenceSpecificEnthalpy().value()),
m_referenceMass(specification.referenceMass().value()),
m_integralContext(integralContext) {
}
template <typename StateView> [[nodiscard]] Report PrepareAfterPhysical(const StateView &state) {
const auto density = state.density();
const auto enthalpy = state.specificEnthalpy();
const auto multiplier = state.generatedCoordinate();
const auto magneticAmplitude = state.template generatedCoordinate<FixedMagneticSpecificEnergy>();
if (enthalpy.Size() == 0 || multiplier.Size() != 1 || magneticAmplitude.Size() != 1 ||
!std::isfinite(enthalpy(0)) || !std::isfinite(multiplier(0)) || !std::isfinite(magneticAmplitude(0))) {
throw std::invalid_argument(
"Core-thermal-balance preparation requires finite enthalpy, multiplier, and magnetic amplitude."
);
}
const double integratedMass = m_integralContext.integrateDensity(density).value();
const bool changed = !m_isPrepared || enthalpy(0) != m_stateEnthalpy || multiplier(0) != m_multiplier ||
magneticAmplitude(0) != m_magneticAmplitude || integratedMass != m_integratedMass;
m_stateEnthalpy = enthalpy(0);
m_multiplier = multiplier(0);
m_magneticAmplitude = magneticAmplitude(0);
m_integratedMass = integratedMass;
const double normalizedMultiplier = m_multiplier / m_referenceEnthalpy;
m_constraintResidual =
m_targetPressure *
(m_stateEnthalpy / m_referenceEnthalpy + 0.25 * normalizedMultiplier * normalizedMultiplier +
thermalMagneticCoupling * m_magneticAmplitude * normalizedMultiplier - 1.0 +
thermalMassCoupling * (m_integratedMass / m_referenceMass - 1.0));
m_magneticConstraintContribution = magneticThermalFeedback * m_magneticAmplitude * m_multiplier;
m_hydrostaticContribution = m_multiplier;
m_isPrepared = true;
return {.stateChanged = changed};
}
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::OwnConstraint,
Row &row
) const {
return row.add(m_constraintResidual);
}
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::HydrostaticBalance,
Row &row
) const {
return row.add(m_hydrostaticContribution);
}
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
Row &row
) const {
return row.add(m_magneticConstraintContribution);
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::Density>,
const Direction &direction,
Row &row
) const {
const double massDirection = m_integralContext.linearizeDensityIntegral(direction.density()).value();
return row.add(thermalMassCoupling * m_targetPressure / m_referenceMass * massDirection);
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::SurfaceShape>,
const Direction &direction,
Row &row
) const {
const double massDirection =
m_integralContext.linearizeSurfaceShapeIntegral(direction.surfaceShape()).value();
return row.add(thermalMassCoupling * m_targetPressure / m_referenceMass * massDirection);
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::SpecificEnthalpy>,
const Direction &direction,
Row &row
) const {
return row.add(m_targetPressure / m_referenceEnthalpy * direction.specificEnthalpy()(0));
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::OwnGeneratedCoordinate>,
const Direction &direction,
Row &row
) const {
return row.add(
m_targetPressure / m_referenceEnthalpy *
(0.5 * m_multiplier / m_referenceEnthalpy + thermalMagneticCoupling * m_magneticAmplitude) *
direction.generatedCoordinate()(0)
);
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::OwnConstraint,
mean_field::stellar::state::GeneratedCoordinateOf<FixedMagneticSpecificEnergy>>,
const Direction &direction,
Row &row
) const {
return row.add(
thermalMagneticCoupling * m_targetPressure * m_multiplier / m_referenceEnthalpy *
direction.template generatedCoordinate<FixedMagneticSpecificEnergy>()(0)
);
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::Density>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::SurfaceShape>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::SpecificEnthalpy>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::OwnGeneratedCoordinate>,
const Direction &direction,
Row &row
) const {
return row.add(direction.generatedCoordinate()(0));
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::HydrostaticBalance,
mean_field::stellar::state::GeneratedCoordinateOf<FixedMagneticSpecificEnergy>>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
mean_field::stellar::state::Density>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
mean_field::stellar::state::SurfaceShape>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
mean_field::stellar::state::SpecificEnthalpy>,
const Direction &,
Row &
) const noexcept {
return mean_field::stellar::zeroDerivative;
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
mean_field::stellar::state::OwnGeneratedCoordinate>,
const Direction &direction,
Row &row
) const {
return row.add(magneticThermalFeedback * m_magneticAmplitude * direction.generatedCoordinate()(0));
}
template <
typename Direction,
typename Row>
[[nodiscard]] auto AddJacobianAction(
mean_field::stellar::Derivative<
mean_field::stellar::equation::ConstraintOf<FixedMagneticSpecificEnergy>,
mean_field::stellar::state::GeneratedCoordinateOf<FixedMagneticSpecificEnergy>>,
const Direction &direction,
Row &row
) const {
return row.add(
magneticThermalFeedback * m_multiplier *
direction.template generatedCoordinate<FixedMagneticSpecificEnergy>()(0)
);
}
[[nodiscard]] bool IsPrepared() const noexcept {
return m_isPrepared;
}
[[nodiscard]] double target() const noexcept {
return m_targetPressure;
}
[[nodiscard]] double referenceEnthalpy() const noexcept {
return m_referenceEnthalpy;
}
[[nodiscard]] double stateEnthalpy() const noexcept {
return m_stateEnthalpy;
}
[[nodiscard]] double referenceMass() const noexcept {
return m_referenceMass;
}
[[nodiscard]] double integratedMass() const noexcept {
return m_integratedMass;
}
[[nodiscard]] IntegralContext integralContext() const noexcept {
return m_integralContext;
}
[[nodiscard]] double multiplier() const noexcept {
return m_multiplier;
}
[[nodiscard]] double magneticAmplitude() const noexcept {
return m_magneticAmplitude;
}
private:
double m_targetPressure{0.0};
double m_referenceEnthalpy{0.0};
double m_referenceMass{0.0};
double m_stateEnthalpy{0.0};
double m_multiplier{0.0};
double m_magneticAmplitude{0.0};
double m_integratedMass{0.0};
double m_constraintResidual{0.0};
double m_magneticConstraintContribution{0.0};
double m_hydrostaticContribution{0.0};
IntegralContext m_integralContext;
bool m_isPrepared{false};
};
/* No separate border-action class is needed. The generic
* preconditioner adapter projects the exact AddJacobianAction providers
* above onto the compiler-inferred border incidence set. */
} // namespace magnetic_specific_energy_extension_test
namespace {
namespace extension = magnetic_specific_energy_extension_test;
namespace blocks = mean_field::utils::blocks;
using MagneticIntegral = extension::FixedMagneticSpecificEnergy;
using MagneticModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
mean_field::eos::Polytrope,
mean_field::surface::Isobaric,
mean_field::integral::FixedTotalMass,
MagneticIntegral>>;
using ReorderedMagneticModel = decltype(mean_field::model::StellarModel(
std::declval<MagneticIntegral>(),
std::declval<mean_field::integral::FixedTotalMass>(),
std::declval<mean_field::surface::Isobaric>(),
std::declval<mean_field::eos::Polytrope>()
));
using RieszDiscretization =
mean_field::equilibrium::StellarDiscretizationFor<mean_field::normalization::PhysicalRieszDiagonal<>>;
using MagneticProblem = mean_field::equilibrium::StellarEquilibriumProblem<MagneticModel, RieszDiscretization>;
using MagneticForm = typename MagneticProblem::FormType;
using MagneticJacobian = typename MagneticProblem::JacobianFormType;
using MagneticBorder = mean_field::preconditioning::CompiledSpecificationBorderFor<MagneticModel>;
using ThermalConstraint = extension::FixedCoreThermalBalance;
using DualExtensionModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
mean_field::eos::Polytrope,
mean_field::surface::Isobaric,
mean_field::integral::FixedTotalMass,
mean_field::integral::FixedAngularMomentum,
MagneticIntegral,
ThermalConstraint>>;
using ReorderedDualExtensionModel = decltype(mean_field::model::StellarModel(
std::declval<ThermalConstraint>(),
std::declval<mean_field::integral::FixedAngularMomentum>(),
std::declval<mean_field::surface::Isobaric>(),
std::declval<MagneticIntegral>(),
std::declval<mean_field::eos::Polytrope>(),
std::declval<mean_field::integral::FixedTotalMass>()
));
using DualExtensionProblem =
mean_field::equilibrium::StellarEquilibriumProblem<DualExtensionModel, RieszDiscretization>;
using DualExtensionForm = typename DualExtensionProblem::FormType;
using DualExtensionJacobian = typename DualExtensionProblem::JacobianFormType;
using DualExtensionBorder = mean_field::preconditioning::CompiledSpecificationBorderFor<DualExtensionModel>;
template <typename View>
concept HasDensity = requires(const View &view) { view.density(); };
template <typename View>
concept HasSpecificEnthalpy = requires(const View &view) { view.specificEnthalpy(); };
template <typename View>
concept HasGeneratedCoordinate = requires(const View &view) { view.generatedCoordinate(); };
template <typename View>
concept HasConstraintResidual = requires(const View &view) { view.constraintResidual(); };
struct ReadSpecificEnthalpyAndAdd final {
template <
typename Direction,
typename Row>
requires requires(
const Direction &direction,
Row &row
) {
direction.specificEnthalpy();
row.add(direction(0));
}
[[nodiscard]] auto operator()(
const Direction &direction,
Row &row
) const {
return row.add(direction(0));
}
};
struct ReadDensityAndAdd final {
template <
typename Direction,
typename Row>
requires requires(
const Direction &direction,
Row &row
) {
direction.density();
row.add(direction(0));
}
[[nodiscard]] auto operator()(
const Direction &direction,
Row &row
) const {
return row.add(direction(0));
}
};
struct ReadGeneratedCoordinateAndAdd final {
template <
typename Direction,
typename Row>
requires requires(
const Direction &direction,
Row &row
) {
direction.generatedCoordinate();
row.add(direction(0));
}
[[nodiscard]] auto operator()(
const Direction &direction,
Row &row
) const {
return row.add(direction(0));
}
};
template <typename View>
concept CanAddSpecificEnthalpyFromGenerated = requires(const View &view) {
view.addSpecificEnthalpyFrom(extension::magneticAmplitudeTerm, ReadGeneratedCoordinateAndAdd{});
};
template <typename View>
concept CanAddConstraintResidualFromEnthalpy = requires(const View &view) {
view.addConstraintResidualFrom(blocks::enthalpy_field.specific_term, ReadSpecificEnthalpyAndAdd{});
};
template <typename View>
concept CanAddConstraintResidualFromGenerated = requires(const View &view) {
view.addConstraintResidualFrom(extension::magneticAmplitudeTerm, ReadGeneratedCoordinateAndAdd{});
};
template <typename View>
concept CanClaimEnthalpyButReadDensity = requires(const View &view) {
view.addConstraintResidualFrom(blocks::enthalpy_field.specific_term, ReadDensityAndAdd{});
};
template <typename Report>
concept HasDidAnyWork = requires(const Report &report) { report.DidAnyWork(); };
/* Deliberately dishonest providers used to exercise the runtime side of
* the exact-provider contract. These compile because their signatures are
* valid; the single-use row must still reject what they actually do. */
struct AddsToOneResidualRowTwice final {
template <typename Row>
[[nodiscard]] auto AddResidual(
mean_field::stellar::equation::OwnConstraint,
Row &row
) const {
const auto firstContribution = row.add(1.0);
static_cast<void>(firstContribution);
return row.add(2.0);
}
};
struct ReportsContributionWithoutAdding final {
template <typename Row>
[[nodiscard]] mean_field::stellar::ContributionAdded AddResidual(
mean_field::stellar::equation::OwnConstraint,
Row &
) const noexcept {
return {};
}
};
struct ReportsStructuralZeroAfterAdding final {
template <typename Row>
[[nodiscard]] mean_field::stellar::StructuralZero AddResidual(
mean_field::stellar::equation::OwnConstraint,
Row &row
) const {
const auto contribution = row.add(1.0);
static_cast<void>(contribution);
return mean_field::stellar::structuralZero;
}
};
[[nodiscard]] mean_field::operators::StellarEquilibriumDependencies makeDependencies() {
return {
.discretization = {.identity = 83003, .revision = 1},
.density = {.identity = 83009, .revision = 1},
.surfaceDeformation = {.identity = 83023, .revision = 1},
.gravityGradient = {.identity = 83047, .revision = 1},
.gravityPotential = {.identity = 83059, .revision = 1},
.enthalpy = {.identity = 83063, .revision = 1},
.bernoulliConstant = {.identity = 83071, .revision = 1},
.rotation = {.identity = 83077, .revision = 1},
.targetMass = {.identity = 83089, .revision = 1}
};
}
[[nodiscard]] mean_field::physics::RigidRotation zeroRotation() {
mfem::Vector angularVelocity(3);
mfem::Vector center(3);
angularVelocity = 0.0;
center = 0.0;
return {angularVelocity, center};
}
[[nodiscard]] double relativeError(
const mfem::Vector &actual,
const mfem::Vector &expected
) {
if (actual.Size() != expected.Size()) {
return std::numeric_limits<double>::infinity();
}
mfem::Vector difference(actual);
difference -= expected;
return difference.Norml2() / std::max({1.0, actual.Norml2(), expected.Norml2()});
}
[[nodiscard]] bool allFinite(const mfem::Vector &vector) {
for (int index = 0; index < vector.Size(); ++index) {
if (!std::isfinite(vector(index))) {
return false;
}
}
return true;
}
} // namespace
TEST_CASE(
"A Third-Party Magnetic Integral Compiles Through Every Coupled System Layer",
"[extensions][integral][type-contract][preconditioning][normalization]"
) {
namespace mf = mean_field;
using StructureToBorderAction =
mf::preconditioning::SpecificationStructureToBorderActionView<MagneticIntegral, MagneticProblem>;
using BorderToStructureAction =
mf::preconditioning::SpecificationBorderToStructureActionView<MagneticIntegral, MagneticProblem>;
using BorderToBorderAction =
mf::preconditioning::SpecificationBorderToBorderActionView<MagneticIntegral, MagneticProblem>;
using PreparedMagneticPhysics =
mf::preconditioning::PreparedSpecificationEquilibriumPhysicsT<MagneticIntegral, MagneticProblem>;
using PreparedMagneticBorder =
mf::preconditioning::PreparedSpecificationBorderPhysicsT<MagneticIntegral, MagneticProblem>;
STATIC_CHECK(std::same_as<MagneticModel, ReorderedMagneticModel>);
STATIC_CHECK(mf::models::ModelSpecification<MagneticIntegral>);
STATIC_CHECK_FALSE(mf::operators::StellarEquilibriumRuntimeContribution<MagneticIntegral>::registered);
STATIC_CHECK_FALSE(HasDidAnyWork<extension::MagneticSpecificEnergyPreparationReport>);
STATIC_CHECK(mf::operators::StellarEquilibriumPhysicsAvailableFor<MagneticIntegral, MagneticModel>);
STATIC_CHECK(mf::equilibrium::StellarEquilibriumModel<MagneticModel>);
STATIC_CHECK(mf::equilibrium::StellarEquilibriumModelDiscretizationCompatible<MagneticModel, RieszDiscretization>);
STATIC_CHECK(MagneticModel::symbolicallySquare);
STATIC_CHECK(MagneticForm::value_block_count == 7);
STATIC_CHECK(MagneticForm::residual_block_count == 7);
STATIC_CHECK(MagneticBorder::valueArity == 2);
STATIC_CHECK(MagneticBorder::residualArity == 2);
STATIC_CHECK(MagneticBorder::specificationCount == 2);
STATIC_CHECK(mf::preconditioning::SpecificationBorderContribution<MagneticIntegral>::RequiredCouplings::size == 3);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual, typename extension::MagneticAmplitudeTerm::value,
MagneticJacobian>
);
STATIC_CHECK(std::same_as<PreparedMagneticPhysics, extension::PreparedMagneticSpecificEnergy>);
STATIC_CHECK(std::constructible_from<PreparedMagneticBorder, const MagneticProblem &>);
STATIC_CHECK(mf::preconditioning::PreparedSpecificationBorderActionFor<PreparedMagneticBorder, MagneticProblem>);
STATIC_CHECK(mf::preconditioning::SpecificationBorderPhysicsAvailableFor<MagneticIntegral, MagneticProblem>);
STATIC_CHECK(mf::preconditioning::DefaultStellarPreconditionerAvailableFor<MagneticProblem>);
// The operation object exposes neither raw endpoint. Selecting a compiled
// pair binds the callback to exactly one source and exactly one row.
STATIC_CHECK_FALSE(HasConstraintResidual<StructureToBorderAction>);
STATIC_CHECK(CanAddConstraintResidualFromEnthalpy<StructureToBorderAction>);
STATIC_CHECK_FALSE(CanAddConstraintResidualFromGenerated<StructureToBorderAction>);
STATIC_CHECK_FALSE(CanClaimEnthalpyButReadDensity<StructureToBorderAction>);
STATIC_CHECK_FALSE(HasSpecificEnthalpy<StructureToBorderAction>);
STATIC_CHECK_FALSE(HasDensity<StructureToBorderAction>);
STATIC_CHECK_FALSE(HasSpecificEnthalpy<BorderToStructureAction>);
STATIC_CHECK(CanAddSpecificEnthalpyFromGenerated<BorderToStructureAction>);
STATIC_CHECK_FALSE(HasGeneratedCoordinate<BorderToStructureAction>);
STATIC_CHECK_FALSE(HasConstraintResidual<BorderToBorderAction>);
STATIC_CHECK(CanAddConstraintResidualFromGenerated<BorderToBorderAction>);
STATIC_CHECK_FALSE(CanAddConstraintResidualFromEnthalpy<BorderToBorderAction>);
STATIC_CHECK(
mf::preconditioning::specificationBorderValueOffset<mf::models::FixedTotalMass, MagneticModel> !=
mf::preconditioning::specificationBorderValueOffset<MagneticIntegral, MagneticModel>
);
STATIC_CHECK(
mf::preconditioning::specificationBorderResidualOffset<mf::models::FixedTotalMass, MagneticModel> !=
mf::preconditioning::specificationBorderResidualOffset<MagneticIntegral, MagneticModel>
);
}
TEST_CASE(
"Exact Physics Provider Rows Reject Inconsistent Contribution Accounting",
"[extensions][integral][runtime-contract]"
) {
namespace mf = mean_field;
const mf::utils::Args arguments = test_utils::setup_args();
mf::fem::FEM finiteElements = mf::fem::setup_fem(arguments.mesh_file, arguments, 0);
REQUIRE(finiteElements.okay());
auto model = mf::model::StellarModel(
mf::eos::Polytrope({.n = 1.0, .K = 0.25}), mf::surface::Isobaric({.Psurf = mf::dimensions::PressureValue{0.0}}),
mf::integral::FixedTotalMass({.Mtotal = mf::dimensions::MassValue{1.0}}),
MagneticIntegral({.target = mf::dimensions::SpecificEnergyValue{1.0}})
);
auto problem = mf::equilibrium::discretize(model, std::move(finiteElements));
using Access = mf::operators::detail::SpecificationRuntimeAccess<MagneticIntegral, MagneticModel>;
using Equations = mf::utils::blocks::type_list<mf::stellar::equation::OwnConstraint>;
using DoubleAdd = mf::operators::detail::ExactResidualProviderSet<AddsToOneResidualRowTwice, Access, Equations>;
using MissingAdd =
mf::operators::detail::ExactResidualProviderSet<ReportsContributionWithoutAdding, Access, Equations>;
using ZeroAfterAdd =
mf::operators::detail::ExactResidualProviderSet<ReportsStructuralZeroAfterAdding, Access, Equations>;
STATIC_CHECK(DoubleAdd::complete);
STATIC_CHECK(MissingAdd::complete);
STATIC_CHECK(ZeroAfterAdd::complete);
mfem::Vector residual(problem.EquationSize());
residual = 0.0;
typename Access::ResidualView restrictedResidual{
problem.GetManifest().residualView(residual), problem.GetPhysicalOperator().GetSurfaceConstraintOperator()
};
CHECK_THROWS_AS(DoubleAdd::Apply(AddsToOneResidualRowTwice{}, restrictedResidual), std::logic_error);
CHECK_THROWS_AS(MissingAdd::Apply(ReportsContributionWithoutAdding{}, restrictedResidual), std::logic_error);
CHECK_THROWS_AS(ZeroAfterAdd::Apply(ReportsStructuralZeroAfterAdding{}, restrictedResidual), std::logic_error);
}
TEST_CASE(
"A Third-Party Magnetic Integral Retains Its Physics Under Normalization And Preconditioning",
"[extensions][integral][physics][jacobian][preconditioning][normalization][integration]"
) {
namespace mf = mean_field;
const mf::utils::Args arguments = test_utils::setup_args();
mf::fem::FEM finiteElements = mf::fem::setup_fem(arguments.mesh_file, arguments, 0);
REQUIRE(finiteElements.okay());
constexpr double referenceRadius = 2.0;
constexpr double gravitationalConstant = 3.0;
constexpr double targetMass = 1.0;
// Deliberately distinct from GM/R (= 1.5). This prevents a target-based
// normalization from accidentally passing a characteristic-scale test.
constexpr double targetMagneticSpecificEnergy = 1.7;
constexpr double referenceEnthalpy = 2.0;
constexpr double magneticAmplitude = 0.8;
auto model = mf::model::StellarModel(
mf::eos::Polytrope({.n = 1.0, .K = 0.25}), mf::surface::Isobaric({.Psurf = mf::dimensions::PressureValue{0.0}}),
mf::integral::FixedTotalMass({.Mtotal = mf::dimensions::MassValue{targetMass}}),
MagneticIntegral({.target = mf::dimensions::SpecificEnergyValue{targetMagneticSpecificEnergy}})
);
auto problem = mf::equilibrium::discretize(
model, mf::equilibrium::makeStellarDiscretization(
std::move(finiteElements), mf::normalization::PhysicalRieszDiagonal{
mf::dimensions::LengthValue{referenceRadius}, gravitationalConstant
}
)
);
using Problem = std::remove_cvref_t<decltype(problem)>;
using Form = typename Problem::FormType;
constexpr auto magneticValueBlock = blocks::get_value_block<Form>(extension::magneticAmplitudeTerm);
constexpr auto magneticResidualBlock = blocks::get_residual_block<Form>(extension::magneticAmplitudeTerm);
const auto &manifest = problem.GetManifest();
const auto &layout = manifest.layout();
const auto &descriptor = manifest.specification<MagneticIntegral>();
CHECK(descriptor.stableId == "FixedMagneticSpecificEnergy");
CHECK(descriptor.role == mf::models::SpecificationRole::invariant);
CHECK(descriptor.columnPolicy == mf::operators::RootColumnPolicy::generated_physical_coordinate);
CHECK(descriptor.valueBlock == magneticValueBlock.index);
CHECK(descriptor.residualBlock == magneticResidualBlock.index);
CHECK(descriptor.target == Catch::Approx(targetMagneticSpecificEnergy));
CHECK(descriptor.residualScale == Catch::Approx(targetMagneticSpecificEnergy));
CHECK(descriptor.targetUnits == "specific_energy");
CHECK(descriptor.residualUnits == "specific_energy");
CHECK(layout.size(magneticValueBlock) == 1);
CHECK(layout.size(magneticResidualBlock) == 1);
auto normalized = mf::normalization::makeNormalizedStellarEquilibriumOperator(problem);
const auto scales = mf::normalization::deriveStellarCharacteristicScales(
mf::dimensions::MassValue{targetMass}, mf::dimensions::LengthValue{referenceRadius}, gravitationalConstant
);
CHECK(scales.specificEnergy == Catch::Approx(1.5));
CHECK(scales.specificEnergy != Catch::Approx(targetMagneticSpecificEnergy));
CHECK(
normalized.GetNormalization().StateFactors()(layout.offset(magneticValueBlock)) ==
Catch::Approx(1.0).epsilon(2.0e-15)
);
CHECK(
normalized.GetNormalization().ResidualFactors()(layout.offset(magneticResidualBlock)) ==
Catch::Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15)
);
mfem::Vector state(problem.StateSize());
state = 0.0;
const auto stateView = manifest.stateView(state);
stateView.block(blocks::density_field.mass_term) = 1.0;
stateView.block(blocks::enthalpy_field.specific_term) = referenceEnthalpy;
stateView.block(blocks::fixed_total_mass_constraint.mass_normalization_term) = 0.25;
stateView.block(extension::magneticAmplitudeTerm) = magneticAmplitude;
auto dependencies = makeDependencies();
problem.Prepare(state, dependencies, zeroRotation());
mfem::Vector residual;
problem.BuildResidual(residual);
REQUIRE(allFinite(residual));
auto residualView = manifest.residualView(residual);
const double expectedInvariant =
0.5 * magneticAmplitude * magneticAmplitude * referenceEnthalpy - targetMagneticSpecificEnergy;
CHECK(residualView.block(extension::magneticAmplitudeTerm)(0) == Catch::Approx(expectedInvariant).epsilon(4.0e-14));
// A centered difference in the generated amplitude probes both its
// magnetic-pressure column and its own nonlinear invariant row.
mfem::Vector amplitudeDirection(problem.StateSize());
amplitudeDirection = 0.0;
constexpr double amplitudeVariation = 0.37;
manifest.stateView(amplitudeDirection).block(extension::magneticAmplitudeTerm)(0) = amplitudeVariation;
mfem::Vector analyticAmplitudeAction;
problem.ApplyLinearization(amplitudeDirection, analyticAmplitudeAction);
const auto analyticAmplitudeView = manifest.residualView(analyticAmplitudeAction);
const auto hydrostaticAmplitudeAction = analyticAmplitudeView.block(blocks::enthalpy_field.specific_term);
std::vector<bool> isSurfaceRow(static_cast<std::size_t>(hydrostaticAmplitudeAction.Size()), false);
for (const int row : problem.GetPressureSurfaceRows().reduced_dofs()) {
isSurfaceRow[static_cast<std::size_t>(row)] = true;
CHECK(hydrostaticAmplitudeAction(row) == Catch::Approx(0.0).margin(2.0e-14));
}
int interiorRowsChecked = 0;
for (int row = 0; row < hydrostaticAmplitudeAction.Size(); ++row) {
if (!isSurfaceRow[static_cast<std::size_t>(row)]) {
CHECK(
hydrostaticAmplitudeAction(row) ==
Catch::Approx(targetMagneticSpecificEnergy * amplitudeVariation).epsilon(3.0e-14)
);
++interiorRowsChecked;
}
}
REQUIRE(interiorRowsChecked > 0);
CHECK(
analyticAmplitudeView.block(extension::magneticAmplitudeTerm)(0) ==
Catch::Approx(magneticAmplitude * referenceEnthalpy * amplitudeVariation).epsilon(3.0e-14)
);
constexpr double epsilon = 2.0e-7;
mfem::Vector plusState(state);
mfem::Vector minusState(state);
manifest.stateView(plusState).block(extension::magneticAmplitudeTerm)(0) += epsilon * amplitudeVariation;
manifest.stateView(minusState).block(extension::magneticAmplitudeTerm)(0) -= epsilon * amplitudeVariation;
mfem::Vector plusResidual;
mfem::Vector minusResidual;
problem.Prepare(plusState, dependencies, zeroRotation());
problem.BuildResidual(plusResidual);
problem.Prepare(minusState, dependencies, zeroRotation());
problem.BuildResidual(minusResidual);
mfem::Vector finiteDifference(plusResidual);
finiteDifference -= minusResidual;
finiteDifference /= 2.0 * epsilon;
CHECK(relativeError(analyticAmplitudeAction, finiteDifference) <= 3.0e-9);
// A structure-only perturbation independently exercises de_B/dh_0.
problem.Prepare(state, dependencies, zeroRotation());
mfem::Vector enthalpyDirection(problem.StateSize());
enthalpyDirection = 0.0;
constexpr double enthalpyVariation = 0.29;
manifest.stateView(enthalpyDirection).block(blocks::enthalpy_field.specific_term)(0) = enthalpyVariation;
mfem::Vector enthalpyAction;
problem.ApplyLinearization(enthalpyDirection, enthalpyAction);
auto enthalpyActionView = manifest.residualView(enthalpyAction);
CHECK(
enthalpyActionView.block(extension::magneticAmplitudeTerm)(0) ==
Catch::Approx(0.5 * magneticAmplitude * magneticAmplitude * enthalpyVariation).epsilon(3.0e-14)
);
mfem::Vector normalizedState;
normalized.NormalizeState(state, normalizedState);
normalized.Prepare(normalizedState, dependencies, zeroRotation());
REQUIRE(normalized.IsPrepared());
mfem::Vector normalizedDirection(problem.StateSize());
for (int index = 0; index < normalizedDirection.Size(); ++index) {
normalizedDirection(index) = 0.021 * std::sin(0.19 * static_cast<double>(index + 1));
}
mfem::Vector physicalDirection;
mfem::Vector physicalAction;
mfem::Vector expectedNormalizedAction;
mfem::Vector actualNormalizedAction;
normalized.DenormalizeState(normalizedDirection, physicalDirection);
problem.ApplyLinearization(physicalDirection, physicalAction);
normalized.NormalizeResidual(physicalAction, expectedNormalizedAction);
normalized.Mult(normalizedDirection, actualNormalizedAction);
CHECK(relativeError(actualNormalizedAction, expectedNormalizedAction) <= 5.0e-13);
auto component = mf::preconditioning::makePreconditioner(problem);
using Component = decltype(component);
STATIC_CHECK(
mf::preconditioning::CompletePreconditionerFor<
mf::preconditioning::PreconditionerPlan<Component>, typename Problem::FormType>
);
STATIC_CHECK(
mf::preconditioning::CompatiblePreconditionerFor<
mf::preconditioning::PreconditionerPlan<Component>, typename Problem::FormType,
typename Problem::JacobianFormType>
);
auto physicalInverse = mf::preconditioning::prepare(problem, component);
REQUIRE(physicalInverse.IsCurrent());
const auto &coordinateMap = physicalInverse.GetCoordinateMap();
mfem::Vector groupedAmplitudeDirection(coordinateMap.PreconditionerCorrectionSize());
mfem::Vector groupedCouplingAction(coordinateMap.PreconditionerResidualSize());
mfem::Vector inferredCouplingAction(problem.EquationSize());
coordinateMap.PackCorrection(amplitudeDirection, groupedAmplitudeDirection);
physicalInverse.GetGroupedPreconditioner().GetCouplings().Mult(groupedAmplitudeDirection, groupedCouplingAction);
coordinateMap.UnpackResidual(groupedCouplingAction, inferredCouplingAction);
CHECK(relativeError(inferredCouplingAction, analyticAmplitudeAction) <= 4.0e-13);
auto scaledInverse = normalized.MakeScaledPreconditioner(physicalInverse);
REQUIRE(scaledInverse.IsCurrent());
mfem::Vector normalizedRightHandSide(problem.EquationSize());
for (int index = 0; index < normalizedRightHandSide.Size(); ++index) {
normalizedRightHandSide(index) = 0.17 * std::sin(0.037 * static_cast<double>(index + 1)) +
0.05 * std::cos(0.023 * static_cast<double>(index + 1));
}
mfem::Vector actualCorrection(problem.StateSize());
mfem::Vector repeatedCorrection(problem.StateSize());
scaledInverse.Mult(normalizedRightHandSide, actualCorrection);
scaledInverse.Mult(normalizedRightHandSide, repeatedCorrection);
REQUIRE(allFinite(actualCorrection));
CHECK(relativeError(actualCorrection, repeatedCorrection) <= 2.0e-14);
mfem::Vector physicalRightHandSide;
mfem::Vector physicalCorrection(problem.StateSize());
mfem::Vector expectedCorrection;
normalized.DenormalizeResidual(normalizedRightHandSide, physicalRightHandSide);
physicalInverse.Mult(physicalRightHandSide, physicalCorrection);
normalized.NormalizeState(physicalCorrection, expectedCorrection);
CHECK(relativeError(actualCorrection, expectedCorrection) <= 5.0e-13);
const auto correctionView = manifest.stateView(actualCorrection);
const double magneticCorrection = correctionView.block(extension::magneticAmplitudeTerm)(0);
CAPTURE(magneticCorrection);
CHECK(std::isfinite(magneticCorrection));
CHECK(std::abs(magneticCorrection) > 1.0e-16);
// The extension's border action snapshots state-dependent coefficients.
// Reusing the same dependency stamps with a different Newton state must
// still invalidate and reconstruct those coefficients.
mfem::Vector changedState(state);
constexpr double changedReferenceEnthalpy = 2.4;
constexpr double changedMagneticAmplitude = 1.1;
auto changedStateView = manifest.stateView(changedState);
auto changedEnthalpy = changedStateView.block(blocks::enthalpy_field.specific_term);
changedEnthalpy = changedReferenceEnthalpy;
changedEnthalpy.SyncAliasMemory(changedState);
auto changedAmplitude = changedStateView.block(extension::magneticAmplitudeTerm);
changedAmplitude = changedMagneticAmplitude;
changedAmplitude.SyncAliasMemory(changedState);
mfem::Vector changedNormalizedState;
normalized.NormalizeState(changedState, changedNormalizedState);
const auto changedPreparation = normalized.Prepare(changedNormalizedState, dependencies, zeroRotation());
CHECK(changedPreparation.template specification<MagneticIntegral>().stateChanged);
CHECK(changedPreparation.assembledResidual);
mfem::Vector changedResidual;
problem.BuildResidual(changedResidual);
const double changedInvariant =
0.5 * changedMagneticAmplitude * changedMagneticAmplitude * changedReferenceEnthalpy -
targetMagneticSpecificEnergy;
CHECK(
manifest.residualView(changedResidual).block(extension::magneticAmplitudeTerm)(0) ==
Catch::Approx(changedInvariant).epsilon(4.0e-14)
);
CHECK_FALSE(physicalInverse.IsCurrent());
CHECK_FALSE(scaledInverse.IsCurrent());
mfem::Vector changedAnalyticAmplitudeAction;
problem.ApplyLinearization(amplitudeDirection, changedAnalyticAmplitudeAction);
mfem::Vector stateDependentDifference(changedAnalyticAmplitudeAction);
stateDependentDifference -= analyticAmplitudeAction;
CHECK(stateDependentDifference.Norml2() > 1.0e-8);
const auto changedRefresh = physicalInverse.Refresh();
CHECK(changedRefresh.specificationActionsRefreshed);
CHECK(changedRefresh.rebuiltSchurComplement);
CHECK(physicalInverse.IsCurrent());
CHECK(scaledInverse.IsCurrent());
physicalInverse.GetGroupedPreconditioner().GetCouplings().Mult(groupedAmplitudeDirection, groupedCouplingAction);
coordinateMap.UnpackResidual(groupedCouplingAction, inferredCouplingAction);
CHECK(relativeError(inferredCouplingAction, changedAnalyticAmplitudeAction) <= 4.0e-13);
const auto noOpRefresh = physicalInverse.Refresh();
CHECK_FALSE(noOpRefresh.DidAnyWork());
}
TEST_CASE(
"Two Directly Coupled Third-Party Scalar Constraints Survive The Complete Inferred Stellar Stack",
"[extensions][variadic][constraint][multiplier][fixed-angular-momentum][jacobian][normalization][preconditioning]["
"lifecycle][integration]"
) {
namespace mf = mean_field;
using Catch::Approx;
using PreparedThermalPhysics =
mf::preconditioning::PreparedSpecificationEquilibriumPhysicsT<ThermalConstraint, DualExtensionProblem>;
using PreparedMagneticBorder =
mf::preconditioning::PreparedSpecificationBorderPhysicsT<MagneticIntegral, DualExtensionProblem>;
using PreparedThermalBorder =
mf::preconditioning::PreparedSpecificationBorderPhysicsT<ThermalConstraint, DualExtensionProblem>;
using ThermalIntegralContext = mf::stellar::DensityVolumeIntegralContext<ThermalConstraint>;
using ThermalTopology =
mf::operators::StellarEquilibriumContributionTopology<ThermalConstraint, DualExtensionModel>;
STATIC_CHECK(std::same_as<DualExtensionModel, ReorderedDualExtensionModel>);
STATIC_CHECK(mf::models::ModelSpecification<MagneticIntegral>);
STATIC_CHECK(mf::models::ModelSpecification<ThermalConstraint>);
STATIC_CHECK_FALSE(mf::operators::StellarEquilibriumRuntimeContribution<MagneticIntegral>::registered);
STATIC_CHECK_FALSE(mf::operators::StellarEquilibriumRuntimeContribution<ThermalConstraint>::registered);
STATIC_CHECK(mf::operators::StellarEquilibriumPhysicsAvailableFor<MagneticIntegral, DualExtensionModel>);
STATIC_CHECK(mf::operators::StellarEquilibriumPhysicsAvailableFor<ThermalConstraint, DualExtensionModel>);
STATIC_CHECK(mf::equilibrium::StellarEquilibriumModel<DualExtensionModel>);
STATIC_CHECK(mf::operators::StellarEquilibriumSystemCompilable<DualExtensionModel>);
STATIC_CHECK(
mf::equilibrium::StellarEquilibriumModelDiscretizationCompatible<DualExtensionModel, RieszDiscretization>
);
STATIC_CHECK(DualExtensionForm::value_block_count == 9);
STATIC_CHECK(DualExtensionForm::residual_block_count == 9);
STATIC_CHECK(DualExtensionBorder::valueArity == 4);
STATIC_CHECK(DualExtensionBorder::residualArity == 4);
STATIC_CHECK(DualExtensionBorder::specificationCount == 4);
STATIC_CHECK(DualExtensionBorder::RequiredCouplings::size == 20);
STATIC_CHECK(ThermalTopology::ResidualEquations::size == 3);
STATIC_CHECK(ThermalTopology::Derivatives::size == 15);
STATIC_CHECK(mf::preconditioning::SpecificationBorderContribution<MagneticIntegral>::RequiredCouplings::size == 3);
STATIC_CHECK(
mf::preconditioning::SpecificationBorderContribution<ThermalConstraint>::RequiredCouplings::size == 12
);
STATIC_CHECK_FALSE(mf::operators::DensityVolumeIntegralSpecification<MagneticIntegral>);
STATIC_CHECK(mf::operators::DensityVolumeIntegralSpecification<ThermalConstraint>);
STATIC_CHECK(mf::normalization::CompleteStellarNormalizationFor<DualExtensionModel, DualExtensionForm>);
STATIC_CHECK(mf::preconditioning::DefaultStellarPreconditionerAvailableFor<DualExtensionProblem>);
STATIC_CHECK(mf::preconditioning::SpecificationBorderPhysicsAvailableFor<MagneticIntegral, DualExtensionProblem>);
STATIC_CHECK(mf::preconditioning::SpecificationBorderPhysicsAvailableFor<ThermalConstraint, DualExtensionProblem>);
STATIC_CHECK(std::same_as<PreparedThermalPhysics, extension::PreparedCoreThermalBalance>);
STATIC_CHECK(std::constructible_from<PreparedThermalPhysics, const ThermalConstraint &, ThermalIntegralContext>);
STATIC_CHECK_FALSE(std::constructible_from<PreparedThermalPhysics, const ThermalConstraint &>);
STATIC_CHECK(std::constructible_from<PreparedMagneticBorder, const DualExtensionProblem &>);
STATIC_CHECK(std::constructible_from<PreparedThermalBorder, const DualExtensionProblem &>);
STATIC_CHECK(
mf::preconditioning::PreparedSpecificationBorderActionFor<PreparedMagneticBorder, DualExtensionProblem>
);
STATIC_CHECK(
mf::preconditioning::PreparedSpecificationBorderActionFor<PreparedThermalBorder, DualExtensionProblem>
);
STATIC_CHECK_FALSE(std::same_as<PreparedMagneticBorder, PreparedThermalBorder>);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual, typename extension::MagneticAmplitudeTerm::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual, mf::utils::blocks::enthalpy::specific::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
mf::utils::blocks::enthalpy::specific::residual, typename extension::MagneticAmplitudeTerm::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::CoreThermalMultiplierTerm::residual,
typename extension::CoreThermalMultiplierTerm::value, DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::CoreThermalMultiplierTerm::residual, mf::utils::blocks::enthalpy::specific::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
mf::utils::blocks::enthalpy::specific::residual, typename extension::CoreThermalMultiplierTerm::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual, typename extension::CoreThermalMultiplierTerm::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::CoreThermalMultiplierTerm::residual, typename extension::MagneticAmplitudeTerm::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::CoreThermalMultiplierTerm::residual, mf::utils::blocks::density::mass::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::CoreThermalMultiplierTerm::residual,
mf::utils::blocks::surface_deformation::parameters::value, DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual, mf::utils::blocks::density::mass::value,
DualExtensionJacobian>
);
STATIC_CHECK(
mf::utils::blocks::has_jacobian_coupling_v<
typename extension::MagneticAmplitudeTerm::residual,
mf::utils::blocks::surface_deformation::parameters::value, DualExtensionJacobian>
);
const mf::utils::Args arguments = test_utils::setup_args();
mf::fem::FEM finiteElements = mf::fem::setup_fem(arguments.mesh_file, arguments, 0);
REQUIRE(finiteElements.okay());
constexpr double referenceRadius = 2.0;
constexpr double gravitationalConstant = 3.0;
constexpr double targetMass = 1.0;
constexpr double targetAngularMomentum = 0.2;
constexpr double targetMagneticSpecificEnergy = 1.7;
constexpr double targetThermalPressure = 1.4;
constexpr double thermalReferenceEnthalpy = 2.6;
constexpr double thermalReferenceMass = 2.3;
constexpr double referenceEnthalpy = 2.0;
constexpr double magneticAmplitude = 0.8;
constexpr double thermalMultiplier = -0.6;
constexpr double angularVelocity = 0.35;
// Deliberately spell the specifications in a noncanonical order. The
// resulting object must still be the exact type audited above.
auto model = mf::model::StellarModel(
ThermalConstraint(
{.target = mf::dimensions::PressureValue{targetThermalPressure},
.referenceSpecificEnthalpy = mf::dimensions::SpecificEnthalpyValue{thermalReferenceEnthalpy},
.referenceMass = mf::dimensions::MassValue{thermalReferenceMass}}
),
mf::integral::FixedAngularMomentum({.Jtotal = mf::dimensions::AngularMomentumValue{targetAngularMomentum}}),
mf::surface::Isobaric({.Psurf = mf::dimensions::PressureValue{0.0}}),
MagneticIntegral({.target = mf::dimensions::SpecificEnergyValue{targetMagneticSpecificEnergy}}),
mf::eos::Polytrope({.n = 1.0, .K = 0.25}),
mf::integral::FixedTotalMass({.Mtotal = mf::dimensions::MassValue{targetMass}})
);
STATIC_CHECK(std::same_as<std::remove_cvref_t<decltype(model)>, DualExtensionModel>);
auto problem = mf::equilibrium::discretize(
model, mf::equilibrium::makeStellarDiscretization(
std::move(finiteElements), mf::normalization::PhysicalRieszDiagonal{
mf::dimensions::LengthValue{referenceRadius}, gravitationalConstant
}
)
);
using Problem = std::remove_cvref_t<decltype(problem)>;
using Form = typename Problem::FormType;
STATIC_CHECK(std::same_as<Problem, DualExtensionProblem>);
constexpr auto magneticValueBlock = blocks::get_value_block<Form>(extension::magneticAmplitudeTerm);
constexpr auto magneticResidualBlock = blocks::get_residual_block<Form>(extension::magneticAmplitudeTerm);
constexpr auto thermalValueBlock = blocks::get_value_block<Form>(extension::coreThermalMultiplierTerm);
constexpr auto thermalResidualBlock = blocks::get_residual_block<Form>(extension::coreThermalMultiplierTerm);
const auto &manifest = problem.GetManifest();
const auto &layout = manifest.layout();
const auto &massDescriptor = manifest.template specification<mf::models::FixedTotalMass>();
const auto &angularDescriptor = manifest.template specification<mf::models::FixedAngularMomentum>();
const auto &magneticDescriptor = manifest.template specification<MagneticIntegral>();
const auto &thermalDescriptor = manifest.template specification<ThermalConstraint>();
REQUIRE(manifest.constraints().size() == 5);
CHECK(magneticDescriptor.stableId == "FixedMagneticSpecificEnergy");
CHECK(thermalDescriptor.stableId == "FixedCoreThermalBalance");
CHECK(magneticDescriptor.columnPolicy == mf::operators::RootColumnPolicy::generated_physical_coordinate);
CHECK(thermalDescriptor.columnPolicy == mf::operators::RootColumnPolicy::existing_physical_multiplier);
CHECK(magneticDescriptor.target == Approx(targetMagneticSpecificEnergy));
CHECK(thermalDescriptor.target == Approx(targetThermalPressure));
CHECK(thermalDescriptor.targetUnits == "pressure");
CHECK(thermalDescriptor.residualUnits == "pressure");
CHECK(magneticDescriptor.valueBlock == magneticValueBlock.index);
CHECK(magneticDescriptor.residualBlock == magneticResidualBlock.index);
CHECK(thermalDescriptor.valueBlock == thermalValueBlock.index);
CHECK(thermalDescriptor.residualBlock == thermalResidualBlock.index);
CHECK(layout.size(magneticValueBlock) == 1);
CHECK(layout.size(magneticResidualBlock) == 1);
CHECK(layout.size(thermalValueBlock) == 1);
CHECK(layout.size(thermalResidualBlock) == 1);
CHECK(massDescriptor.valueBlock != angularDescriptor.valueBlock);
CHECK(massDescriptor.valueBlock != magneticDescriptor.valueBlock);
CHECK(massDescriptor.valueBlock != thermalDescriptor.valueBlock);
CHECK(angularDescriptor.valueBlock != magneticDescriptor.valueBlock);
CHECK(angularDescriptor.valueBlock != thermalDescriptor.valueBlock);
CHECK(magneticDescriptor.valueBlock != thermalDescriptor.valueBlock);
CHECK(massDescriptor.residualBlock != angularDescriptor.residualBlock);
CHECK(massDescriptor.residualBlock != magneticDescriptor.residualBlock);
CHECK(massDescriptor.residualBlock != thermalDescriptor.residualBlock);
CHECK(angularDescriptor.residualBlock != magneticDescriptor.residualBlock);
CHECK(angularDescriptor.residualBlock != thermalDescriptor.residualBlock);
CHECK(magneticDescriptor.residualBlock != thermalDescriptor.residualBlock);
auto normalized = mf::normalization::makeNormalizedStellarEquilibriumOperator(problem);
const auto scales = mf::normalization::deriveStellarCharacteristicScales(
mf::dimensions::MassValue{targetMass}, mf::dimensions::LengthValue{referenceRadius}, gravitationalConstant
);
CHECK(
normalized.GetNormalization().StateFactors()(layout.offset(magneticValueBlock)) == Approx(1.0).epsilon(2.0e-15)
);
CHECK(
normalized.GetNormalization().StateFactors()(layout.offset(thermalValueBlock)) ==
Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15)
);
CHECK(
normalized.GetNormalization().ResidualFactors()(layout.offset(magneticResidualBlock)) ==
Approx(1.0 / scales.specificEnergy).epsilon(2.0e-15)
);
CHECK(
normalized.GetNormalization().ResidualFactors()(layout.offset(thermalResidualBlock)) ==
Approx(1.0 / scales.pressure).epsilon(2.0e-15)
);
mfem::Vector state(problem.StateSize());
state = 0.0;
const auto stateView = manifest.stateView(state);
stateView.block(blocks::density_field.mass_term) = 1.0;
stateView.block(blocks::enthalpy_field.specific_term) = referenceEnthalpy;
stateView.block(blocks::fixed_total_mass_constraint.mass_normalization_term) = 0.25;
stateView.block(blocks::fixed_angular_momentum_constraint.angular_velocity_term) = angularVelocity;
stateView.generatedCoordinate<MagneticIntegral>() = magneticAmplitude;
stateView.generatedCoordinate<ThermalConstraint>() = thermalMultiplier;
auto dependencies = makeDependencies();
const auto preparation = problem.Prepare(state, dependencies);
REQUIRE(preparation.generatedPhysicalControl);
REQUIRE(preparation.template specification<mf::models::FixedAngularMomentum>().generatedRotation);
REQUIRE(preparation.template specification<MagneticIntegral>().stateChanged);
REQUIRE(preparation.template specification<ThermalConstraint>().stateChanged);
REQUIRE(problem.IsPrepared());
const auto &preparedThermal = problem.GetPreparedOperator().template GetPreparedContribution<ThermalConstraint>();
const double integratedMass = preparedThermal.integratedMass();
const double independentlyIntegratedMass =
problem.GetPhysicalOperator().GetMassNormalizationOperator().GetCurrentMass();
CHECK(integratedMass == Approx(independentlyIntegratedMass).epsilon(3.0e-14));
mfem::Vector residual;
problem.BuildResidual(residual);
REQUIRE(allFinite(residual));
const auto residualView = manifest.residualView(residual);
const double expectedMagneticResidual = 0.5 * magneticAmplitude * magneticAmplitude * referenceEnthalpy -
targetMagneticSpecificEnergy +
extension::magneticThermalFeedback * magneticAmplitude * thermalMultiplier;
const double normalizedThermalMultiplier = thermalMultiplier / thermalReferenceEnthalpy;
const double expectedThermalResidual =
targetThermalPressure * (referenceEnthalpy / thermalReferenceEnthalpy +
0.25 * normalizedThermalMultiplier * normalizedThermalMultiplier +
extension::thermalMagneticCoupling * magneticAmplitude * normalizedThermalMultiplier -
1.0 + extension::thermalMassCoupling * (integratedMass / thermalReferenceMass - 1.0));
CHECK(residualView.constraintResidual<MagneticIntegral>()(0) == Approx(expectedMagneticResidual).epsilon(4.0e-14));
CHECK(residualView.constraintResidual<ThermalConstraint>()(0) == Approx(expectedThermalResidual).epsilon(4.0e-14));
CHECK(expectedMagneticResidual != Approx(expectedThermalResidual));
const auto makeBorderDirection = [&](const double magneticVariation, const double thermalVariation) {
mfem::Vector direction(problem.StateSize());
direction = 0.0;
const auto view = manifest.stateView(direction);
view.generatedCoordinate<MagneticIntegral>() = magneticVariation;
view.generatedCoordinate<ThermalConstraint>() = thermalVariation;
return direction;
};
constexpr double magneticVariation = 0.31;
constexpr double thermalVariation = -0.27;
const mfem::Vector magneticDirection = makeBorderDirection(magneticVariation, 0.0);
const mfem::Vector thermalDirection = makeBorderDirection(0.0, thermalVariation);
mfem::Vector combinedDirection(magneticDirection);
combinedDirection += thermalDirection;
mfem::Vector magneticAction;
mfem::Vector thermalAction;
mfem::Vector combinedAction;
problem.ApplyLinearization(magneticDirection, magneticAction);
problem.ApplyLinearization(thermalDirection, thermalAction);
problem.ApplyLinearization(combinedDirection, combinedAction);
const auto magneticActionView = manifest.residualView(magneticAction);
const auto thermalActionView = manifest.residualView(thermalAction);
CHECK(
magneticActionView.constraintResidual<MagneticIntegral>()(0) ==
Approx(
(magneticAmplitude * referenceEnthalpy + extension::magneticThermalFeedback * thermalMultiplier) *
magneticVariation
)
.epsilon(4.0e-14)
);
CHECK(
magneticActionView.constraintResidual<ThermalConstraint>()(0) ==
Approx(
extension::thermalMagneticCoupling * targetThermalPressure * normalizedThermalMultiplier * magneticVariation
)
.epsilon(4.0e-14)
);
CHECK(
thermalActionView.constraintResidual<MagneticIntegral>()(0) ==
Approx(extension::magneticThermalFeedback * magneticAmplitude * thermalVariation).epsilon(4.0e-14)
);
CHECK(
thermalActionView.constraintResidual<ThermalConstraint>()(0) ==
Approx(
targetThermalPressure / thermalReferenceEnthalpy *
(0.5 * normalizedThermalMultiplier + extension::thermalMagneticCoupling * magneticAmplitude) *
thermalVariation
)
.epsilon(4.0e-14)
);
const auto checkInteriorHydrostaticAction = [&](mfem::Vector &action, const double expected) {
const mfem::Vector hydrostatic = manifest.residualView(action).block(blocks::enthalpy_field.specific_term);
std::vector<bool> surfaceRows(static_cast<std::size_t>(hydrostatic.Size()), false);
for (const int row : problem.GetPressureSurfaceRows().reduced_dofs()) {
surfaceRows[static_cast<std::size_t>(row)] = true;
CHECK(hydrostatic(row) == Approx(0.0).margin(3.0e-14));
}
int interiorRows = 0;
for (int row = 0; row < hydrostatic.Size(); ++row) {
if (!surfaceRows[static_cast<std::size_t>(row)]) {
CHECK(hydrostatic(row) == Approx(expected).epsilon(4.0e-14));
++interiorRows;
}
}
REQUIRE(interiorRows > 0);
};
checkInteriorHydrostaticAction(magneticAction, targetMagneticSpecificEnergy * magneticVariation);
checkInteriorHydrostaticAction(thermalAction, thermalVariation);
// The complete public residual provides an independent centered difference
// for both generated columns at once. Because only the two nested scalar
// states change, the physical core is intentionally reusable here.
constexpr double differenceStep = 2.0e-7;
mfem::Vector plusState(state);
mfem::Vector minusState(state);
plusState.Add(differenceStep, combinedDirection);
minusState.Add(-differenceStep, combinedDirection);
problem.Prepare(plusState, dependencies);
mfem::Vector plusResidual;
problem.BuildResidual(plusResidual);
problem.Prepare(minusState, dependencies);
mfem::Vector minusResidual;
problem.BuildResidual(minusResidual);
mfem::Vector difference(plusResidual);
difference -= minusResidual;
difference /= 2.0 * differenceStep;
CHECK(relativeError(combinedAction, difference) <= 5.0e-9);
problem.Prepare(state, dependencies);
mfem::Vector enthalpyDirection(problem.StateSize());
enthalpyDirection = 0.0;
constexpr double enthalpyVariation = 0.23;
manifest.stateView(enthalpyDirection).block(blocks::enthalpy_field.specific_term)(0) = enthalpyVariation;
mfem::Vector enthalpyAction;
problem.ApplyLinearization(enthalpyDirection, enthalpyAction);
const auto enthalpyActionView = manifest.residualView(enthalpyAction);
CHECK(
enthalpyActionView.block(extension::magneticAmplitudeTerm)(0) ==
Approx(0.5 * magneticAmplitude * magneticAmplitude * enthalpyVariation).epsilon(4.0e-14)
);
CHECK(
enthalpyActionView.block(extension::coreThermalMultiplierTerm)(0) ==
Approx(targetThermalPressure / thermalReferenceEnthalpy * enthalpyVariation).epsilon(4.0e-14)
);
// The new astronomy-facing integration context evaluates a true global
// finite-element functional. Its density derivative must agree with the
// independently assembled fixed-mass row and with a nonlinear centered
// difference, while the exact border action preserves the same coupling.
mfem::Vector densityDirection(problem.StateSize());
densityDirection = 0.0;
auto densityDirectionBlock = manifest.stateView(densityDirection).block(blocks::density_field.mass_term);
for (int index = 0; index < densityDirectionBlock.Size(); ++index) {
densityDirectionBlock(index) = 0.17 + 0.09 * std::sin(0.37 * static_cast<double>(index + 1));
}
mfem::Vector densityAction;
problem.ApplyLinearization(densityDirection, densityAction);
const auto densityActionView = manifest.residualView(densityAction);
const double densityMassAction =
densityActionView.block(blocks::fixed_total_mass_constraint.mass_normalization_term)(0);
const double expectedThermalDensityAction =
extension::thermalMassCoupling * targetThermalPressure / thermalReferenceMass * densityMassAction;
CHECK(
densityActionView.constraintResidual<ThermalConstraint>()(0) ==
Approx(expectedThermalDensityAction).epsilon(8.0e-13)
);
CHECK(densityActionView.constraintResidual<MagneticIntegral>()(0) == Approx(0.0).margin(2.0e-14));
// This row is exactly linear in density. Use a deliberately macroscopic
// perturbation so that subtracting two O(1) residuals does not bury the
// O(step) signal in roundoff; there is no truncation-error tradeoff here.
constexpr double densityDifferenceStep = 1.0e-4;
mfem::Vector plusDensityState(state);
mfem::Vector minusDensityState(state);
plusDensityState.Add(densityDifferenceStep, densityDirection);
minusDensityState.Add(-densityDifferenceStep, densityDirection);
auto plusDensityDependencies = dependencies;
plusDensityDependencies.density.revision = 2;
problem.Prepare(plusDensityState, plusDensityDependencies);
mfem::Vector plusDensityResidual;
problem.BuildResidual(plusDensityResidual);
auto minusDensityDependencies = plusDensityDependencies;
minusDensityDependencies.density.revision = 3;
problem.Prepare(minusDensityState, minusDensityDependencies);
mfem::Vector minusDensityResidual;
problem.BuildResidual(minusDensityResidual);
const double finiteDifferenceThermalDensity =
(manifest.residualView(plusDensityResidual).constraintResidual<ThermalConstraint>()(0) -
manifest.residualView(minusDensityResidual).constraintResidual<ThermalConstraint>()(0)) /
(2.0 * densityDifferenceStep);
CHECK(finiteDifferenceThermalDensity == Approx(expectedThermalDensityAction).epsilon(2.0e-8));
dependencies = minusDensityDependencies;
dependencies.density.revision = 4;
problem.Prepare(state, dependencies);
// Physical-volume integration also depends on the deformed stellar
// domain. The restricted context maps a surface-shape direction through
// the current deformation and differentiates the same global integral.
mfem::Vector surfaceDirection(problem.StateSize());
surfaceDirection = 0.0;
auto surfaceDirectionBlock =
manifest.stateView(surfaceDirection).block(blocks::surface_deformation_field.parameters_term);
for (int index = 0; index < surfaceDirectionBlock.Size(); ++index) {
surfaceDirectionBlock(index) = 0.021 * std::cos(0.29 * static_cast<double>(index + 1));
}
mfem::Vector surfaceAction;
problem.ApplyLinearization(surfaceDirection, surfaceAction);
const auto surfaceActionView = manifest.residualView(surfaceAction);
const double surfaceMassAction =
surfaceActionView.block(blocks::fixed_total_mass_constraint.mass_normalization_term)(0);
CHECK(
surfaceActionView.constraintResidual<ThermalConstraint>()(0) ==
Approx(extension::thermalMassCoupling * targetThermalPressure / thermalReferenceMass * surfaceMassAction)
.epsilon(8.0e-13)
);
CHECK(surfaceActionView.constraintResidual<MagneticIntegral>()(0) == Approx(0.0).margin(2.0e-14));
// Unlike the density column, this column differentiates the nonlinear
// domain deformation. Check the complete public residual independently
// so the test exercises the surface-to-displacement map, physical-volume
// integration, and typed constraint row as one composed operation.
constexpr double surfaceDifferenceStep = 1.0e-3;
mfem::Vector plusSurfaceState(state);
mfem::Vector minusSurfaceState(state);
plusSurfaceState.Add(surfaceDifferenceStep, surfaceDirection);
minusSurfaceState.Add(-surfaceDifferenceStep, surfaceDirection);
auto plusSurfaceDependencies = dependencies;
++plusSurfaceDependencies.surfaceDeformation.revision;
problem.Prepare(plusSurfaceState, plusSurfaceDependencies);
mfem::Vector plusSurfaceResidual;
problem.BuildResidual(plusSurfaceResidual);
auto minusSurfaceDependencies = plusSurfaceDependencies;
++minusSurfaceDependencies.surfaceDeformation.revision;
problem.Prepare(minusSurfaceState, minusSurfaceDependencies);
mfem::Vector minusSurfaceResidual;
problem.BuildResidual(minusSurfaceResidual);
const double finiteDifferenceThermalSurface =
(manifest.residualView(plusSurfaceResidual).constraintResidual<ThermalConstraint>()(0) -
manifest.residualView(minusSurfaceResidual).constraintResidual<ThermalConstraint>()(0)) /
(2.0 * surfaceDifferenceStep);
CHECK(
finiteDifferenceThermalSurface ==
Approx(surfaceActionView.constraintResidual<ThermalConstraint>()(0)).epsilon(3.0e-7)
);
dependencies = minusSurfaceDependencies;
++dependencies.surfaceDeformation.revision;
problem.Prepare(state, dependencies);
mfem::Vector normalizedState;
normalized.NormalizeState(state, normalizedState);
const auto normalizedPreparation = normalized.Prepare(normalizedState, dependencies);
REQUIRE(normalizedPreparation.generatedPhysicalControl);
REQUIRE(normalizedPreparation.template specification<MagneticIntegral>().stateChanged == false);
REQUIRE(normalizedPreparation.template specification<ThermalConstraint>().stateChanged == false);
REQUIRE(normalized.IsPrepared());
mfem::Vector expectedNormalizedResidual;
mfem::Vector actualNormalizedResidual;
normalized.NormalizeResidual(residual, expectedNormalizedResidual);
normalized.BuildResidual(actualNormalizedResidual);
CHECK(relativeError(actualNormalizedResidual, expectedNormalizedResidual) <= 5.0e-13);
const auto normalizedResidualView = manifest.residualView(actualNormalizedResidual);
CHECK(
normalizedResidualView.block(extension::magneticAmplitudeTerm)(0) ==
Approx(expectedMagneticResidual / scales.specificEnergy).epsilon(4.0e-14)
);
CHECK(
normalizedResidualView.block(extension::coreThermalMultiplierTerm)(0) ==
Approx(expectedThermalResidual / scales.pressure).epsilon(4.0e-14)
);
mfem::Vector normalizedDirection;
normalized.NormalizeState(combinedDirection, normalizedDirection);
mfem::Vector physicalCombinedAction;
mfem::Vector expectedNormalizedAction;
mfem::Vector actualNormalizedAction;
problem.ApplyLinearization(combinedDirection, physicalCombinedAction);
normalized.NormalizeResidual(physicalCombinedAction, expectedNormalizedAction);
normalized.Mult(normalizedDirection, actualNormalizedAction);
CHECK(relativeError(actualNormalizedAction, expectedNormalizedAction) <= 5.0e-13);
auto component = mf::preconditioning::makePreconditioner(problem);
using Component = std::remove_cvref_t<decltype(component)>;
STATIC_CHECK(Component::borderValueArity == 4);
STATIC_CHECK(Component::borderResidualArity == 4);
STATIC_CHECK(
mf::preconditioning::CompletePreconditionerFor<
mf::preconditioning::PreconditionerPlan<Component>, typename Problem::FormType>
);
STATIC_CHECK(
mf::preconditioning::CompatiblePreconditionerFor<
mf::preconditioning::PreconditionerPlan<Component>, typename Problem::FormType,
typename Problem::JacobianFormType>
);
auto physicalInverse = mf::preconditioning::prepare(problem, component);
REQUIRE(physicalInverse.IsCurrent());
const auto &coordinateMap = physicalInverse.GetCoordinateMap();
const auto inferredBorderAction = [&](const mfem::Vector &rootDirection) {
mfem::Vector groupedDirection(coordinateMap.PreconditionerCorrectionSize());
mfem::Vector groupedAction(coordinateMap.PreconditionerResidualSize());
mfem::Vector rootAction(problem.EquationSize());
coordinateMap.PackCorrection(rootDirection, groupedDirection);
physicalInverse.GetGroupedPreconditioner().GetCouplings().Mult(groupedDirection, groupedAction);
coordinateMap.UnpackResidual(groupedAction, rootAction);
return rootAction;
};
const mfem::Vector inferredMagneticAction = inferredBorderAction(magneticDirection);
const mfem::Vector inferredThermalAction = inferredBorderAction(thermalDirection);
CHECK(relativeError(inferredMagneticAction, magneticAction) <= 5.0e-13);
CHECK(relativeError(inferredThermalAction, thermalAction) <= 5.0e-13);
mfem::Vector inferredEnthalpyBorderAction = inferredBorderAction(enthalpyDirection);
const auto inferredEnthalpyView = manifest.residualView(inferredEnthalpyBorderAction);
CHECK(
inferredEnthalpyView.block(extension::magneticAmplitudeTerm)(0) ==
Approx(enthalpyActionView.block(extension::magneticAmplitudeTerm)(0)).epsilon(4.0e-13)
);
CHECK(
inferredEnthalpyView.block(extension::coreThermalMultiplierTerm)(0) ==
Approx(enthalpyActionView.block(extension::coreThermalMultiplierTerm)(0)).epsilon(4.0e-13)
);
mfem::Vector inferredDensityBorderAction = inferredBorderAction(densityDirection);
const auto inferredDensityView = manifest.residualView(inferredDensityBorderAction);
CHECK(
inferredDensityView.constraintResidual<ThermalConstraint>()(0) ==
Approx(densityActionView.constraintResidual<ThermalConstraint>()(0)).epsilon(8.0e-13)
);
CHECK(inferredDensityView.constraintResidual<MagneticIntegral>()(0) == Approx(0.0).margin(2.0e-14));
mfem::Vector inferredSurfaceBorderAction = inferredBorderAction(surfaceDirection);
const auto inferredSurfaceView = manifest.residualView(inferredSurfaceBorderAction);
CHECK(
inferredSurfaceView.constraintResidual<ThermalConstraint>()(0) ==
Approx(surfaceActionView.constraintResidual<ThermalConstraint>()(0)).epsilon(8.0e-13)
);
CHECK(inferredSurfaceView.constraintResidual<MagneticIntegral>()(0) == Approx(0.0).margin(2.0e-14));
auto scaledInverse = normalized.MakeScaledPreconditioner(physicalInverse);
REQUIRE(scaledInverse.IsCurrent());
mfem::Vector normalizedRightHandSide(problem.EquationSize());
for (int index = 0; index < normalizedRightHandSide.Size(); ++index) {
normalizedRightHandSide(index) = 0.13 * std::sin(0.031 * static_cast<double>(index + 1)) +
0.04 * std::cos(0.019 * static_cast<double>(index + 1));
}
auto rightHandSideView = manifest.residualView(normalizedRightHandSide);
rightHandSideView.block(extension::magneticAmplitudeTerm) = 0.37;
rightHandSideView.block(extension::coreThermalMultiplierTerm) = -0.29;
mfem::Vector firstCorrection(problem.StateSize());
mfem::Vector repeatedCorrection(problem.StateSize());
scaledInverse.Mult(normalizedRightHandSide, firstCorrection);
scaledInverse.Mult(normalizedRightHandSide, repeatedCorrection);
REQUIRE(allFinite(firstCorrection));
CHECK(relativeError(firstCorrection, repeatedCorrection) <= 3.0e-14);
const auto correctionView = manifest.stateView(static_cast<const mfem::Vector &>(firstCorrection));
const double magneticCorrection = correctionView.block(extension::magneticAmplitudeTerm)(0);
const double thermalCorrection = correctionView.block(extension::coreThermalMultiplierTerm)(0);
CAPTURE(magneticCorrection, thermalCorrection);
CHECK(std::abs(magneticCorrection) > 1.0e-16);
CHECK(std::abs(thermalCorrection) > 1.0e-16);
// Change coefficients in both nested slots while deliberately reusing the
// same dependency stamps. Both cached actions must become stale and both
// must be reconstructed by one variadic refresh.
constexpr double changedEnthalpy = 2.4;
constexpr double changedMagneticAmplitude = 1.1;
constexpr double changedThermalMultiplier = 0.5;
mfem::Vector changedState(state);
const auto changedStateView = manifest.stateView(changedState);
changedStateView.block(blocks::enthalpy_field.specific_term) = changedEnthalpy;
changedStateView.block(extension::magneticAmplitudeTerm) = changedMagneticAmplitude;
changedStateView.block(extension::coreThermalMultiplierTerm) = changedThermalMultiplier;
mfem::Vector changedNormalizedState;
normalized.NormalizeState(changedState, changedNormalizedState);
const auto changedPreparation = normalized.Prepare(changedNormalizedState, dependencies);
CHECK(changedPreparation.template specification<MagneticIntegral>().stateChanged);
CHECK(changedPreparation.template specification<ThermalConstraint>().stateChanged);
CHECK_FALSE(physicalInverse.IsCurrent());
CHECK_FALSE(scaledInverse.IsCurrent());
mfem::Vector changedResidual;
problem.BuildResidual(changedResidual);
const auto changedResidualView = manifest.residualView(changedResidual);
const double changedExpectedMagneticResidual =
0.5 * changedMagneticAmplitude * changedMagneticAmplitude * changedEnthalpy - targetMagneticSpecificEnergy +
extension::magneticThermalFeedback * changedMagneticAmplitude * changedThermalMultiplier;
const double changedNormalizedThermalMultiplier = changedThermalMultiplier / thermalReferenceEnthalpy;
const double changedExpectedThermalResidual =
targetThermalPressure *
(changedEnthalpy / thermalReferenceEnthalpy +
0.25 * changedNormalizedThermalMultiplier * changedNormalizedThermalMultiplier +
extension::thermalMagneticCoupling * changedMagneticAmplitude * changedNormalizedThermalMultiplier - 1.0 +
extension::thermalMassCoupling * (integratedMass / thermalReferenceMass - 1.0));
CHECK(
changedResidualView.block(extension::magneticAmplitudeTerm)(0) ==
Approx(changedExpectedMagneticResidual).epsilon(4.0e-14)
);
CHECK(
changedResidualView.block(extension::coreThermalMultiplierTerm)(0) ==
Approx(changedExpectedThermalResidual).epsilon(4.0e-14)
);
mfem::Vector changedMagneticAction;
mfem::Vector changedThermalAction;
problem.ApplyLinearization(magneticDirection, changedMagneticAction);
problem.ApplyLinearization(thermalDirection, changedThermalAction);
mfem::Vector magneticActionChange(changedMagneticAction);
mfem::Vector thermalActionChange(changedThermalAction);
magneticActionChange -= magneticAction;
thermalActionChange -= thermalAction;
CHECK(magneticActionChange.Norml2() > 1.0e-8);
CHECK(thermalActionChange.Norml2() > 1.0e-8);
const auto refresh = physicalInverse.Refresh();
CHECK(refresh.specificationActionsRefreshed);
CHECK(refresh.rebuiltSchurComplement);
CHECK(refresh.DidAnyWork());
REQUIRE(physicalInverse.IsCurrent());
REQUIRE(scaledInverse.IsCurrent());
const mfem::Vector refreshedMagneticAction = inferredBorderAction(magneticDirection);
const mfem::Vector refreshedThermalAction = inferredBorderAction(thermalDirection);
CHECK(relativeError(refreshedMagneticAction, changedMagneticAction) <= 5.0e-13);
CHECK(relativeError(refreshedThermalAction, changedThermalAction) <= 5.0e-13);
const auto noOpRefresh = physicalInverse.Refresh();
CHECK_FALSE(noOpRefresh.DidAnyWork());
mfem::Vector refreshedCorrection(problem.StateSize());
scaledInverse.Mult(normalizedRightHandSide, refreshedCorrection);
REQUIRE(allFinite(refreshedCorrection));
}
Reference in New Issue View Git Blame Copy Permalink