1371 lines
64 KiB
C++
1371 lines
64 KiB
C++
#include <algorithm>
|
|
#include <array>
|
|
#include <concepts>
|
|
#include <limits>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string_view>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include <catch2/matchers/catch_matchers.hpp>
|
|
#include <catch2/catch_test_macros.hpp>
|
|
#include <mfem.hpp>
|
|
|
|
import mean_field;
|
|
import test_helpers;
|
|
|
|
namespace {
|
|
template <typename ManifestType, typename Specification>
|
|
concept HasRootManifestSpecificationDescriptor = requires(const ManifestType &manifest) {
|
|
{
|
|
manifest.template specification<Specification>()
|
|
} -> std::same_as<const mean_field::operators::RootConstraintDescriptor &>;
|
|
};
|
|
|
|
template <typename View, typename Term>
|
|
concept CanMutateManifestBlock = requires(View &view, const Term &term) {
|
|
view.block(term)(0) = 1.0;
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept HasLvalueRootViewFactories = requires(
|
|
const ManifestType &manifest,
|
|
mfem::Vector &mutableVector,
|
|
const mfem::Vector &readOnlyVector
|
|
) {
|
|
{ manifest.stateView(mutableVector) } -> std::same_as<typename ManifestType::MutableStateView>;
|
|
{ manifest.stateView(readOnlyVector) } -> std::same_as<typename ManifestType::StateView>;
|
|
{ manifest.directionView(readOnlyVector) } -> std::same_as<typename ManifestType::DirectionView>;
|
|
{ manifest.residualView(mutableVector) } -> std::same_as<typename ManifestType::RootResidualView>;
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept StateViewAcceptsTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.stateView(std::declval<mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept StateViewAcceptsConstTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.stateView(std::declval<const mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept DirectionViewAcceptsTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.directionView(std::declval<mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept DirectionViewAcceptsConstTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.directionView(std::declval<const mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept ResidualViewAcceptsTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.residualView(std::declval<mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept ResidualViewAcceptsConstTemporaryVector = requires(const ManifestType &manifest) {
|
|
manifest.residualView(std::declval<const mfem::Vector &&>());
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept TemporaryManifestProvidesStateView = requires(mfem::Vector &vector) {
|
|
std::declval<ManifestType &&>().stateView(vector);
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept TemporaryManifestProvidesReadOnlyStateView = requires(const mfem::Vector &vector) {
|
|
std::declval<ManifestType &&>().stateView(vector);
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept TemporaryManifestProvidesDirectionView = requires(const mfem::Vector &vector) {
|
|
std::declval<ManifestType &&>().directionView(vector);
|
|
};
|
|
|
|
template <typename ManifestType>
|
|
concept TemporaryManifestProvidesResidualView = requires(mfem::Vector &vector) {
|
|
std::declval<ManifestType &&>().residualView(vector);
|
|
};
|
|
|
|
using CanonicalModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::models::FixedTotalMass,
|
|
mean_field::surface::Isobaric>>;
|
|
|
|
using PermutedModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::models::FixedTotalMass,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::eos::Polytrope>>;
|
|
|
|
using CentralDensityModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::models::FixedCentralDensity,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::eos::Polytrope,
|
|
mean_field::models::FixedTotalMass>>;
|
|
|
|
using Form = mean_field::operators::CompiledStellarEquilibriumForm<CanonicalModel>;
|
|
using JacobianForm =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<CanonicalModel>;
|
|
using Manifest = mean_field::operators::CompiledRootManifest<CanonicalModel, Form, JacobianForm>;
|
|
using CentralForm = mean_field::utils::blocks::central_density_bordered_stellar_equilibrium_form;
|
|
using CentralJacobianForm = mean_field::utils::blocks::central_density_bordered_stellar_equilibrium_jacobian_form;
|
|
using CentralManifest =
|
|
mean_field::operators::CompiledRootManifest<CentralDensityModel, CentralForm, CentralJacobianForm>;
|
|
|
|
using AngularMomentumModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
mean_field::models::FixedAngularMomentum>>;
|
|
using AngularMomentumForm = mean_field::operators::CompiledStellarEquilibriumForm<AngularMomentumModel>;
|
|
using AngularMomentumJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<AngularMomentumModel>;
|
|
using AngularMomentumManifest = mean_field::operators::CompiledRootManifest<
|
|
AngularMomentumModel,
|
|
AngularMomentumForm,
|
|
AngularMomentumJacobian>;
|
|
|
|
class MockFixedMagneticSpecificEnergy final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::SpecificEnergyValue target;
|
|
};
|
|
|
|
using ScalarDimensionless = mean_field::models::CoordinateNormalization<
|
|
mean_field::models::RieszTopology::global_scalar,
|
|
mean_field::models::PhysicalScaleLaw::dimensionless>;
|
|
using ScalarSpecificEnergy = mean_field::models::CoordinateNormalization<
|
|
mean_field::models::RieszTopology::global_scalar,
|
|
mean_field::models::PhysicalScaleLaw::specific_energy>;
|
|
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
|
|
MockFixedMagneticSpecificEnergy,
|
|
"RootManifestMockFixedMagneticSpecificEnergy",
|
|
mean_field::models::ModelTypeList<
|
|
mean_field::utils::blocks::density::mass::value,
|
|
mean_field::utils::blocks::surface_deformation::parameters::value>,
|
|
mean_field::models::ModelTypeList<
|
|
mean_field::utils::blocks::enthalpy::specific::residual>,
|
|
mean_field::models::GeneratedNormalization<ScalarDimensionless, ScalarSpecificEnergy>,
|
|
mean_field::models::GeneratedManifest<
|
|
"mock_magnetic_specific_energy.amplitude",
|
|
"a_B",
|
|
"mock_magnetic_specific_energy.residual",
|
|
"R_EB",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
explicit MockFixedMagneticSpecificEnergy(const Parameters parameters) noexcept
|
|
: m_target(parameters.target) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::SpecificEnergyValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::SpecificEnergyValue m_target;
|
|
};
|
|
|
|
template <mean_field::models::FixedString Name, typename ManifestDefinition>
|
|
class MockManifestIdentityConstraint final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::SpecificEnergyValue target;
|
|
};
|
|
|
|
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
|
|
MockManifestIdentityConstraint,
|
|
Name,
|
|
mean_field::models::DependsOn<mean_field::models::stellar::state::Density>,
|
|
mean_field::models::Affects<mean_field::models::stellar::equation::HydrostaticBalance>,
|
|
mean_field::models::GlobalScalarNormalization<
|
|
mean_field::models::PhysicalScaleLaw::dimensionless,
|
|
mean_field::models::PhysicalScaleLaw::specific_energy>,
|
|
ManifestDefinition>;
|
|
|
|
explicit MockManifestIdentityConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::SpecificEnergyValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::SpecificEnergyValue m_target;
|
|
};
|
|
|
|
struct NonConstexprGeneratedManifest final {
|
|
inline static std::string_view valueStableId = "nonconstexpr_manifest.coordinate";
|
|
static constexpr std::string_view valueSymbol = "q_nc";
|
|
static constexpr std::string_view residualStableId = "nonconstexpr_manifest.residual";
|
|
static constexpr std::string_view residualSymbol = "R_nc";
|
|
static constexpr std::string_view targetUnits = "specific_energy";
|
|
static constexpr std::string_view residualUnits = "specific_energy";
|
|
static constexpr bool available = true;
|
|
};
|
|
|
|
struct ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view valueStableId = "valid_structural_manifest.coordinate";
|
|
static constexpr std::string_view valueSymbol = "q_valid";
|
|
static constexpr std::string_view residualStableId = "valid_structural_manifest.residual";
|
|
static constexpr std::string_view residualSymbol = "R_valid";
|
|
static constexpr std::string_view targetUnits = "specific_energy";
|
|
static constexpr std::string_view residualUnits = "specific_energy";
|
|
static constexpr bool available = true;
|
|
};
|
|
|
|
struct EmptyValueStableIdManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view valueStableId = "";
|
|
};
|
|
|
|
struct EmptyValueSymbolManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view valueSymbol = "";
|
|
};
|
|
|
|
struct EmptyResidualStableIdManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view residualStableId = "";
|
|
};
|
|
|
|
struct EmptyResidualSymbolManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view residualSymbol = "";
|
|
};
|
|
|
|
struct EmptyTargetUnitsManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view targetUnits = "";
|
|
};
|
|
|
|
struct EmptyResidualUnitsManifest final : ValidStructuralGeneratedManifest {
|
|
static constexpr std::string_view residualUnits = "";
|
|
};
|
|
|
|
struct NonConstexprGeneratedUnitsManifest final : ValidStructuralGeneratedManifest {
|
|
inline static std::string_view targetUnits = "specific_energy";
|
|
};
|
|
|
|
using MockGeneratedValueIdCollision = MockManifestIdentityConstraint<
|
|
"RootManifestMockGeneratedValueIdCollision",
|
|
mean_field::models::GeneratedManifest<
|
|
"fixed_total_mass.multiplier",
|
|
"C_value_collision",
|
|
"mock_generated_value_collision.residual",
|
|
"R_value_collision",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
using MockGeneratedResidualIdCollision = MockManifestIdentityConstraint<
|
|
"RootManifestMockGeneratedResidualIdCollision",
|
|
mean_field::models::GeneratedManifest<
|
|
"mock_generated_residual_collision.coordinate",
|
|
"q_residual_collision",
|
|
"fixed_total_mass.residual",
|
|
"R_residual_collision",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
using MockPhysicalValueIdCollision = MockManifestIdentityConstraint<
|
|
"RootManifestMockPhysicalValueIdCollision",
|
|
mean_field::models::GeneratedManifest<
|
|
"density",
|
|
"q_physical_value_collision",
|
|
"mock_physical_value_collision.residual",
|
|
"R_physical_value_collision",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
using MockPhysicalResidualIdCollision = MockManifestIdentityConstraint<
|
|
"RootManifestMockPhysicalResidualIdCollision",
|
|
mean_field::models::GeneratedManifest<
|
|
"mock_physical_residual_collision.coordinate",
|
|
"q_physical_residual_collision",
|
|
"hydrostatic_balance",
|
|
"R_physical_residual_collision",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
using MockReusedManifestSymbols = MockManifestIdentityConstraint<
|
|
"RootManifestMockReusedSymbols",
|
|
mean_field::models::GeneratedManifest<
|
|
"mock_reused_symbols.coordinate",
|
|
"C",
|
|
"mock_reused_symbols.residual",
|
|
"R_M",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
using MockNonConstexprManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockNonConstexprManifest",
|
|
NonConstexprGeneratedManifest>;
|
|
|
|
using MockValidStructuralManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockValidStructuralManifest",
|
|
ValidStructuralGeneratedManifest>;
|
|
using MockEmptyValueStableIdManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyValueStableIdManifest",
|
|
EmptyValueStableIdManifest>;
|
|
using MockEmptyValueSymbolManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyValueSymbolManifest",
|
|
EmptyValueSymbolManifest>;
|
|
using MockEmptyResidualStableIdManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyResidualStableIdManifest",
|
|
EmptyResidualStableIdManifest>;
|
|
using MockEmptyResidualSymbolManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyResidualSymbolManifest",
|
|
EmptyResidualSymbolManifest>;
|
|
using MockEmptyTargetUnitsManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyTargetUnitsManifest",
|
|
EmptyTargetUnitsManifest>;
|
|
using MockEmptyResidualUnitsManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockEmptyResidualUnitsManifest",
|
|
EmptyResidualUnitsManifest>;
|
|
using MockNonConstexprUnitsManifest = MockManifestIdentityConstraint<
|
|
"RootManifestMockNonConstexprUnitsManifest",
|
|
NonConstexprGeneratedUnitsManifest>;
|
|
|
|
struct AlternatingManifestTarget final {
|
|
double first;
|
|
double subsequent;
|
|
mutable int evaluations{0};
|
|
|
|
[[nodiscard]] double value() const noexcept {
|
|
return evaluations++ == 0 ? first : subsequent;
|
|
}
|
|
};
|
|
|
|
class MockInconsistentManifestScale final {
|
|
public:
|
|
struct Parameters final {
|
|
double first;
|
|
double subsequent;
|
|
};
|
|
|
|
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
|
|
MockInconsistentManifestScale,
|
|
"RootManifestMockInconsistentScale",
|
|
mean_field::models::DependsOn<mean_field::models::stellar::state::Density>,
|
|
mean_field::models::Affects<mean_field::models::stellar::equation::HydrostaticBalance>,
|
|
mean_field::models::GlobalScalarNormalization<
|
|
mean_field::models::PhysicalScaleLaw::dimensionless,
|
|
mean_field::models::PhysicalScaleLaw::specific_energy>,
|
|
ValidStructuralGeneratedManifest>;
|
|
|
|
explicit MockInconsistentManifestScale(const Parameters parameters) noexcept
|
|
: m_target{parameters.first, parameters.subsequent} {
|
|
}
|
|
|
|
[[nodiscard]] const AlternatingManifestTarget &target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
AlternatingManifestTarget m_target;
|
|
};
|
|
|
|
struct NonConvertibleTarget final {
|
|
struct Magnitude final { };
|
|
|
|
[[nodiscard]] constexpr Magnitude value() const noexcept {
|
|
return {};
|
|
}
|
|
};
|
|
|
|
class MockNonConvertibleManifestTarget final {
|
|
public:
|
|
struct Parameters final { };
|
|
|
|
using ScalarDescription = mean_field::stellar::ScalarConstraint<
|
|
mean_field::dimensions::quantity::SpecificEnergy,
|
|
mean_field::dimensions::quantity::Dimensionless,
|
|
mean_field::dimensions::quantity::SpecificEnergy,
|
|
"mock_nonconvertible_target.coordinate",
|
|
"q_bad",
|
|
"mock_nonconvertible_target.residual",
|
|
"R_bad">;
|
|
using ModelDefinition = mean_field::integral::FixedScalarWithPhysicalCoordinate<
|
|
MockNonConvertibleManifestTarget,
|
|
"RootManifestMockNonConvertibleTarget",
|
|
mean_field::stellar::Reads<mean_field::stellar::state::Density>,
|
|
mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
|
|
ScalarDescription>;
|
|
|
|
explicit MockNonConvertibleManifestTarget(Parameters) noexcept {
|
|
}
|
|
|
|
[[nodiscard]] constexpr NonConvertibleTarget target() const noexcept {
|
|
return {};
|
|
}
|
|
};
|
|
|
|
class MockMismatchedManifestWithoutResidualReference final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::DensityValue target;
|
|
};
|
|
|
|
using ScalarDescription = mean_field::stellar::ScalarConstraint<
|
|
mean_field::dimensions::quantity::Density,
|
|
mean_field::dimensions::quantity::Dimensionless,
|
|
mean_field::dimensions::quantity::SpecificEnergy,
|
|
"mock_mismatched_without_reference.coordinate",
|
|
"q_missing_ref",
|
|
"mock_mismatched_without_reference.residual",
|
|
"R_missing_ref">;
|
|
using ModelDefinition = mean_field::integral::FixedScalarWithPhysicalCoordinate<
|
|
MockMismatchedManifestWithoutResidualReference,
|
|
"RootManifestMockMismatchedWithoutResidualReference",
|
|
mean_field::stellar::Reads<mean_field::stellar::state::Density>,
|
|
mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
|
|
ScalarDescription>;
|
|
|
|
explicit MockMismatchedManifestWithoutResidualReference(
|
|
const Parameters parameters
|
|
) noexcept : m_target(parameters.target) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::DensityValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::DensityValue m_target;
|
|
};
|
|
|
|
class MockMismatchedManifestWithResidualReference final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::DensityValue target;
|
|
mean_field::dimensions::SpecificEnergyValue residualReference;
|
|
};
|
|
|
|
using ScalarDescription = mean_field::stellar::ScalarConstraint<
|
|
mean_field::dimensions::quantity::Density,
|
|
mean_field::dimensions::quantity::Dimensionless,
|
|
mean_field::dimensions::quantity::SpecificEnergy,
|
|
"mock_mismatched_with_reference.coordinate",
|
|
"q_ref",
|
|
"mock_mismatched_with_reference.residual",
|
|
"R_ref">;
|
|
using ModelDefinition = mean_field::integral::FixedScalarWithPhysicalCoordinate<
|
|
MockMismatchedManifestWithResidualReference,
|
|
"RootManifestMockMismatchedWithResidualReference",
|
|
mean_field::stellar::Reads<mean_field::stellar::state::Density>,
|
|
mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
|
|
ScalarDescription>;
|
|
|
|
explicit MockMismatchedManifestWithResidualReference(
|
|
const Parameters parameters
|
|
) noexcept
|
|
: m_target(parameters.target),
|
|
m_residualReference(parameters.residualReference) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::DensityValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::SpecificEnergyValue
|
|
residualReference() const noexcept {
|
|
return m_residualReference;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::DensityValue m_target;
|
|
mean_field::dimensions::SpecificEnergyValue m_residualReference;
|
|
};
|
|
|
|
class MockMismatchedManifestWithWrongResidualReference final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::DensityValue target;
|
|
};
|
|
|
|
using ScalarDescription = mean_field::stellar::ScalarConstraint<
|
|
mean_field::dimensions::quantity::Density,
|
|
mean_field::dimensions::quantity::Dimensionless,
|
|
mean_field::dimensions::quantity::SpecificEnergy,
|
|
"mock_mismatched_wrong_reference.coordinate",
|
|
"q_wrong_ref",
|
|
"mock_mismatched_wrong_reference.residual",
|
|
"R_wrong_ref">;
|
|
using ModelDefinition = mean_field::integral::FixedScalarWithPhysicalCoordinate<
|
|
MockMismatchedManifestWithWrongResidualReference,
|
|
"RootManifestMockMismatchedWithWrongResidualReference",
|
|
mean_field::stellar::Reads<mean_field::stellar::state::Density>,
|
|
mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
|
|
ScalarDescription>;
|
|
|
|
explicit MockMismatchedManifestWithWrongResidualReference(
|
|
const Parameters parameters
|
|
) noexcept : m_target(parameters.target) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::DensityValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::DensityValue
|
|
residualReference() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::DensityValue m_target;
|
|
};
|
|
|
|
class MockMissingManifest final {
|
|
public:
|
|
struct Parameters final { };
|
|
|
|
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
|
|
MockMissingManifest,
|
|
"RootManifestMockMissingManifest",
|
|
mean_field::models::ModelTypeList<mean_field::utils::blocks::density::mass::value>,
|
|
mean_field::models::ModelTypeList<mean_field::utils::blocks::enthalpy::specific::residual>>;
|
|
|
|
explicit MockMissingManifest(Parameters) noexcept {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::SpecificEnergyValue target() const noexcept {
|
|
return mean_field::dimensions::SpecificEnergyValue{1.0};
|
|
}
|
|
};
|
|
|
|
class MockUncompiledSurface final {
|
|
public:
|
|
struct Parameters final { };
|
|
using ModelDefinition = mean_field::surface::BoundaryCondition<
|
|
MockUncompiledSurface,
|
|
"RootManifestMockUncompiledSurface">;
|
|
|
|
explicit MockUncompiledSurface(Parameters) noexcept {
|
|
}
|
|
};
|
|
|
|
class MockInvariantNamedLikeSurface final {
|
|
public:
|
|
struct Parameters final {
|
|
mean_field::dimensions::SpecificEnergyValue target;
|
|
};
|
|
|
|
using ModelDefinition = mean_field::integral::FixedWithPhysicalCoordinate<
|
|
MockInvariantNamedLikeSurface,
|
|
"IsobaricSurface",
|
|
mean_field::models::DependsOn<mean_field::models::stellar::state::Density>,
|
|
mean_field::models::Affects<mean_field::models::stellar::equation::HydrostaticBalance>,
|
|
mean_field::models::GlobalScalarNormalization<
|
|
mean_field::models::PhysicalScaleLaw::dimensionless,
|
|
mean_field::models::PhysicalScaleLaw::specific_energy>,
|
|
mean_field::models::GeneratedManifest<
|
|
"same_name_invariant.coordinate",
|
|
"q_same",
|
|
"same_name_invariant.residual",
|
|
"R_same",
|
|
"specific_energy",
|
|
"specific_energy">>;
|
|
|
|
explicit MockInvariantNamedLikeSurface(Parameters parameters) noexcept : m_target(parameters.target) {
|
|
}
|
|
|
|
[[nodiscard]] mean_field::dimensions::SpecificEnergyValue target() const noexcept {
|
|
return m_target;
|
|
}
|
|
|
|
private:
|
|
mean_field::dimensions::SpecificEnergyValue m_target;
|
|
};
|
|
|
|
using GenericManifestModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
MockFixedMagneticSpecificEnergy>>;
|
|
using GenericManifestForm = mean_field::operators::CompiledStellarEquilibriumForm<GenericManifestModel>;
|
|
using GenericManifestJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<GenericManifestModel>;
|
|
using GenericManifest = mean_field::operators::EquilibriumSystemManifest<
|
|
GenericManifestModel,
|
|
GenericManifestForm,
|
|
GenericManifestJacobian>;
|
|
|
|
using InconsistentScaleModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
MockInconsistentManifestScale>>;
|
|
using InconsistentScaleForm = mean_field::operators::CompiledStellarEquilibriumForm<InconsistentScaleModel>;
|
|
using InconsistentScaleJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<InconsistentScaleModel>;
|
|
using InconsistentScaleManifest = mean_field::operators::EquilibriumSystemManifest<
|
|
InconsistentScaleModel,
|
|
InconsistentScaleForm,
|
|
InconsistentScaleJacobian>;
|
|
|
|
using NonConvertibleTargetModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
MockNonConvertibleManifestTarget>>;
|
|
using NonConvertibleTargetForm =
|
|
mean_field::operators::CompiledStellarEquilibriumForm<NonConvertibleTargetModel>;
|
|
|
|
using MissingManifestModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
MockMissingManifest>>;
|
|
using MissingManifestForm = mean_field::operators::CompiledStellarEquilibriumForm<MissingManifestModel>;
|
|
|
|
using UncompiledSurfaceModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
MockUncompiledSurface,
|
|
mean_field::models::FixedTotalMass>>;
|
|
using UncompiledSurfaceForm = mean_field::operators::CompiledStellarEquilibriumForm<UncompiledSurfaceModel>;
|
|
using UncompiledSurfaceJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<UncompiledSurfaceModel>;
|
|
using UncompiledSurfaceManifest = mean_field::operators::EquilibriumSystemManifest<
|
|
UncompiledSurfaceModel,
|
|
UncompiledSurfaceForm,
|
|
UncompiledSurfaceJacobian>;
|
|
|
|
using CrossRoleNameCollisionModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
MockInvariantNamedLikeSurface>>;
|
|
using CrossRoleNameCollisionForm =
|
|
mean_field::operators::CompiledStellarEquilibriumForm<CrossRoleNameCollisionModel>;
|
|
using CrossRoleNameCollisionJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<CrossRoleNameCollisionModel>;
|
|
using CrossRoleNameCollisionManifest = mean_field::operators::EquilibriumSystemManifest<
|
|
CrossRoleNameCollisionModel,
|
|
CrossRoleNameCollisionForm,
|
|
CrossRoleNameCollisionJacobian>;
|
|
|
|
template <typename Specification>
|
|
using ManifestExtensionModel = mean_field::model::StellarModel<mean_field::models::SpecificationSet<
|
|
mean_field::eos::Polytrope,
|
|
mean_field::surface::Isobaric,
|
|
mean_field::models::FixedTotalMass,
|
|
Specification>>;
|
|
|
|
template <typename Specification>
|
|
using ManifestExtensionForm =
|
|
mean_field::operators::CompiledStellarEquilibriumForm<ManifestExtensionModel<Specification>>;
|
|
|
|
using MissingResidualReferenceModel =
|
|
ManifestExtensionModel<MockMismatchedManifestWithoutResidualReference>;
|
|
using MissingResidualReferenceForm =
|
|
ManifestExtensionForm<MockMismatchedManifestWithoutResidualReference>;
|
|
using WrongResidualReferenceModel =
|
|
ManifestExtensionModel<MockMismatchedManifestWithWrongResidualReference>;
|
|
using WrongResidualReferenceForm =
|
|
ManifestExtensionForm<MockMismatchedManifestWithWrongResidualReference>;
|
|
using DistinctResidualReferenceModel =
|
|
ManifestExtensionModel<MockMismatchedManifestWithResidualReference>;
|
|
using DistinctResidualReferenceForm =
|
|
ManifestExtensionForm<MockMismatchedManifestWithResidualReference>;
|
|
using DistinctResidualReferenceJacobian =
|
|
mean_field::operators::CompiledStellarEquilibriumJacobianForm<
|
|
DistinctResidualReferenceModel>;
|
|
using DistinctResidualReferenceManifest =
|
|
mean_field::operators::EquilibriumSystemManifest<
|
|
DistinctResidualReferenceModel,
|
|
DistinctResidualReferenceForm,
|
|
DistinctResidualReferenceJacobian>;
|
|
|
|
[[nodiscard]] Manifest make_manifest() {
|
|
const std::array<int, Form::value_block_count> valueSizes{2, 3, 4, 5, 6, 1};
|
|
const std::array<int, Form::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1};
|
|
const CanonicalModel model{
|
|
mean_field::eos::Polytrope{1.0, 0.25},
|
|
mean_field::surface::Isobaric{mean_field::dimensions::PressureValue{0.125}},
|
|
mean_field::models::FixedTotalMass{mean_field::dimensions::MassValue{2.5}}
|
|
};
|
|
return {valueSizes, residualSizes, model, 3};
|
|
}
|
|
} // namespace
|
|
|
|
TEST_CASE(
|
|
"Manifest Capability Rejects Malformed Targets And Foreign Generated Blocks",
|
|
"[root-manifest][type-contract][sfinae]"
|
|
) {
|
|
using namespace mean_field;
|
|
|
|
STATIC_CHECK(models::ModelSpecification<MockNonConvertibleManifestTarget>);
|
|
STATIC_CHECK_FALSE(std::convertible_to<NonConvertibleTarget::Magnitude, double>);
|
|
STATIC_CHECK_FALSE(models::CompleteGeneratedScalarDimensionsFor<MockNonConvertibleManifestTarget>);
|
|
STATIC_CHECK_FALSE(models::CompleteGeneratedNormalizationFor<MockNonConvertibleManifestTarget>);
|
|
STATIC_CHECK_FALSE(models::CompleteGeneratedManifestFor<MockNonConvertibleManifestTarget>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<NonConvertibleTargetModel>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
NonConvertibleTargetModel,
|
|
NonConvertibleTargetForm>);
|
|
|
|
// A typed target may intentionally differ from the equation's residual
|
|
// quantity, but then the manifest needs a residual-valued physical
|
|
// reference. Absence and the wrong quantity are both rejected without a
|
|
// hard template error.
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<
|
|
MockMismatchedManifestWithoutResidualReference>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<
|
|
MockMismatchedManifestWithWrongResidualReference>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<
|
|
MockMismatchedManifestWithResidualReference>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
MissingResidualReferenceModel>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
WrongResidualReferenceModel>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
MissingResidualReferenceModel,
|
|
MissingResidualReferenceForm>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
WrongResidualReferenceModel,
|
|
WrongResidualReferenceForm>);
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<
|
|
DistinctResidualReferenceModel,
|
|
DistinctResidualReferenceForm>);
|
|
|
|
// This is a valid compiled form for GenericManifestModel, but its magnetic
|
|
// generated pair is foreign to CanonicalModel. Described metadata alone
|
|
// must not make that mismatched model/form pair manifest-compilable.
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<
|
|
GenericManifestModel,
|
|
GenericManifestForm>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
CanonicalModel,
|
|
GenericManifestForm>);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Dimensionally Distinct Constraint Residuals Use Their Own Physical Reference",
|
|
"[root-manifest][type-contract][physics][scaling]"
|
|
) {
|
|
using namespace mean_field;
|
|
|
|
const auto model = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockMismatchedManifestWithResidualReference({
|
|
.target = dimensions::DensityValue{12.0},
|
|
.residualReference = dimensions::SpecificEnergyValue{3.25}
|
|
})
|
|
);
|
|
const std::array<int, DistinctResidualReferenceForm::value_block_count>
|
|
valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, DistinctResidualReferenceForm::residual_block_count>
|
|
residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const DistinctResidualReferenceManifest manifest(
|
|
valueSizes,
|
|
residualSizes,
|
|
model,
|
|
3
|
|
);
|
|
|
|
const auto &descriptor =
|
|
manifest.template specification<MockMismatchedManifestWithResidualReference>();
|
|
CHECK(descriptor.target == 12.0);
|
|
CHECK(descriptor.targetUnits == "density");
|
|
CHECK(descriptor.residualUnits == "specific_energy");
|
|
CHECK(descriptor.residualScale == 3.25);
|
|
CHECK(manifest.residualBlocks().back().scale == 3.25);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Root Manifest Stable IDs Are Unique Per Block Kind",
|
|
"[root-manifest][identity][type-contract]"
|
|
) {
|
|
using namespace mean_field;
|
|
|
|
using GeneratedValueCollisionModel = ManifestExtensionModel<MockGeneratedValueIdCollision>;
|
|
using GeneratedResidualCollisionModel = ManifestExtensionModel<MockGeneratedResidualIdCollision>;
|
|
using PhysicalValueCollisionModel = ManifestExtensionModel<MockPhysicalValueIdCollision>;
|
|
using PhysicalResidualCollisionModel = ManifestExtensionModel<MockPhysicalResidualIdCollision>;
|
|
using ReusedSymbolsModel = ManifestExtensionModel<MockReusedManifestSymbols>;
|
|
using NonConstexprManifestModel = ManifestExtensionModel<MockNonConstexprManifest>;
|
|
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockGeneratedValueIdCollision>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockGeneratedResidualIdCollision>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockPhysicalValueIdCollision>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockPhysicalResidualIdCollision>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockReusedManifestSymbols>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<GeneratedValueCollisionModel>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<GeneratedResidualCollisionModel>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<PhysicalValueCollisionModel>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<PhysicalResidualCollisionModel>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
GeneratedValueCollisionModel,
|
|
ManifestExtensionForm<MockGeneratedValueIdCollision>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
GeneratedResidualCollisionModel,
|
|
ManifestExtensionForm<MockGeneratedResidualIdCollision>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
PhysicalValueCollisionModel,
|
|
ManifestExtensionForm<MockPhysicalValueIdCollision>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
PhysicalResidualCollisionModel,
|
|
ManifestExtensionForm<MockPhysicalResidualIdCollision>>);
|
|
|
|
// Symbols are mathematical presentation labels, not machine identities.
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<
|
|
ReusedSymbolsModel,
|
|
ManifestExtensionForm<MockReusedManifestSymbols>>);
|
|
|
|
// A broad physics manifest may be structurally complete while its identity
|
|
// strings are unsuitable for a constexpr compiled root descriptor. The
|
|
// root capability must reject it through detection, not a hard error.
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<NonConstexprGeneratedManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockNonConstexprManifest>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<NonConstexprManifestModel>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
NonConstexprManifestModel,
|
|
ManifestExtensionForm<MockNonConstexprManifest>>);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Root Manifest Requires Complete Constant Generated Metadata",
|
|
"[root-manifest][identity][type-contract][sfinae]"
|
|
) {
|
|
using namespace mean_field;
|
|
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<ValidStructuralGeneratedManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockValidStructuralManifest>);
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockValidStructuralManifest>,
|
|
ManifestExtensionForm<MockValidStructuralManifest>>);
|
|
|
|
// These structural manifests deliberately lie through available=true.
|
|
// The root capability must inspect every identity and unit field itself.
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyValueStableIdManifest>);
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyValueSymbolManifest>);
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyResidualStableIdManifest>);
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyResidualSymbolManifest>);
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyTargetUnitsManifest>);
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<EmptyResidualUnitsManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyValueStableIdManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyValueSymbolManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyResidualStableIdManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyResidualSymbolManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyTargetUnitsManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockEmptyResidualUnitsManifest>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyValueStableIdManifest>>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyValueSymbolManifest>>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyResidualStableIdManifest>>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyResidualSymbolManifest>>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyTargetUnitsManifest>>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<
|
|
ManifestExtensionModel<MockEmptyResidualUnitsManifest>>);
|
|
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyValueStableIdManifest>,
|
|
ManifestExtensionForm<MockEmptyValueStableIdManifest>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyValueSymbolManifest>,
|
|
ManifestExtensionForm<MockEmptyValueSymbolManifest>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyResidualStableIdManifest>,
|
|
ManifestExtensionForm<MockEmptyResidualStableIdManifest>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyResidualSymbolManifest>,
|
|
ManifestExtensionForm<MockEmptyResidualSymbolManifest>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyTargetUnitsManifest>,
|
|
ManifestExtensionForm<MockEmptyTargetUnitsManifest>>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockEmptyResidualUnitsManifest>,
|
|
ManifestExtensionForm<MockEmptyResidualUnitsManifest>>);
|
|
|
|
// Constexpr enforcement covers unit metadata as well as IDs and symbols.
|
|
STATIC_CHECK(models::GeneratedManifestDefinition<NonConstexprGeneratedUnitsManifest>);
|
|
STATIC_CHECK(models::CompleteGeneratedManifestFor<MockNonConstexprUnitsManifest>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<
|
|
ManifestExtensionModel<MockNonConstexprUnitsManifest>,
|
|
ManifestExtensionForm<MockNonConstexprUnitsManifest>>);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Self-Described Generated Specifications Enter The Manifest Without Combination Code",
|
|
"[root-manifest][variadic][extension]"
|
|
) {
|
|
using namespace mean_field;
|
|
using MockValue = utils::blocks::generated_value_block<
|
|
models::PhysicalCoordinateFor<MockFixedMagneticSpecificEnergy>>;
|
|
using MockResidual = utils::blocks::generated_residual_block<
|
|
models::ResidualFor<MockFixedMagneticSpecificEnergy>>;
|
|
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<GenericManifestModel>);
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<GenericManifestModel, GenericManifestForm>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<MissingManifestModel, MissingManifestForm>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<UncompiledSurfaceModel>);
|
|
STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<UncompiledSurfaceModel, UncompiledSurfaceForm>);
|
|
STATIC_CHECK_FALSE(UncompiledSurfaceManifest::hasCompleteEquilibriumCompiler);
|
|
STATIC_CHECK(
|
|
UncompiledSurfaceManifest::compilationClass ==
|
|
models::EquilibriumSystemCompilation::equation_contributions_only);
|
|
STATIC_CHECK(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<
|
|
MockFixedMagneticSpecificEnergy>);
|
|
STATIC_CHECK(preconditioning::SpecificationBorderContribution<
|
|
MockFixedMagneticSpecificEnergy>::registered);
|
|
STATIC_CHECK(utils::blocks::contains_type_v<
|
|
MockValue,
|
|
typename preconditioning::SpecificationBorderContribution<
|
|
MockFixedMagneticSpecificEnergy>::CorrectionBlocks>);
|
|
STATIC_CHECK(utils::blocks::contains_type_v<
|
|
preconditioning::Coupling<
|
|
utils::blocks::enthalpy::specific::residual,
|
|
MockValue>,
|
|
typename preconditioning::SpecificationBorderContribution<
|
|
MockFixedMagneticSpecificEnergy>::RequiredCouplings>);
|
|
STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<GenericManifestModel>);
|
|
|
|
const auto model = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockFixedMagneticSpecificEnergy({.target = dimensions::SpecificEnergyValue{7.5}})
|
|
);
|
|
const std::array<int, GenericManifestForm::value_block_count> valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, GenericManifestForm::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const GenericManifest manifest(valueSizes, residualSizes, model, 3);
|
|
|
|
REQUIRE(manifest.valueBlocks().size() == 7);
|
|
REQUIRE(manifest.residualBlocks().size() == 7);
|
|
CHECK(manifest.valueBlocks().back().stableId == "mock_magnetic_specific_energy.amplitude");
|
|
CHECK(manifest.valueBlocks().back().symbol == "a_B");
|
|
CHECK(manifest.valueBlocks().back().columnPolicy ==
|
|
operators::RootColumnPolicy::generated_physical_coordinate);
|
|
CHECK(manifest.residualBlocks().back().stableId == "mock_magnetic_specific_energy.residual");
|
|
CHECK(manifest.residualBlocks().back().symbol == "R_EB");
|
|
CHECK(manifest.residualBlocks().back().scale == 7.5);
|
|
|
|
const auto descriptor = std::find_if(
|
|
manifest.constraints().begin(),
|
|
manifest.constraints().end(),
|
|
[](const operators::RootConstraintDescriptor &candidate) {
|
|
return candidate.stableId == "RootManifestMockFixedMagneticSpecificEnergy";
|
|
}
|
|
);
|
|
REQUIRE(descriptor != manifest.constraints().end());
|
|
CHECK(descriptor->valueBlock == utils::blocks::type_index_v<
|
|
MockValue,
|
|
typename GenericManifestForm::value_blocks>);
|
|
CHECK(descriptor->residualBlock == utils::blocks::type_index_v<
|
|
MockResidual,
|
|
typename GenericManifestForm::residual_blocks>);
|
|
CHECK(descriptor->target == 7.5);
|
|
CHECK(descriptor->residualScale == 7.5);
|
|
CHECK(descriptor->targetUnits == "specific_energy");
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Root Manifest Rejects Non-Finite Targets And Scales",
|
|
"[root-manifest][runtime-contract][scaling]"
|
|
) {
|
|
using namespace mean_field;
|
|
|
|
const std::array<int, GenericManifestForm::value_block_count> valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, GenericManifestForm::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const auto nonFiniteTargetModel = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockFixedMagneticSpecificEnergy({
|
|
.target = dimensions::SpecificEnergyValue{std::numeric_limits<double>::quiet_NaN()}
|
|
})
|
|
);
|
|
|
|
CHECK_THROWS_WITH(
|
|
GenericManifest(valueSizes, residualSizes, nonFiniteTargetModel, 3),
|
|
"An equilibrium-system manifest constraint requires a finite target."
|
|
);
|
|
|
|
const auto nonFiniteResidualReferenceModel = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockMismatchedManifestWithResidualReference({
|
|
.target = dimensions::DensityValue{12.0},
|
|
.residualReference = dimensions::SpecificEnergyValue{
|
|
std::numeric_limits<double>::quiet_NaN()}
|
|
})
|
|
);
|
|
const std::array<int, DistinctResidualReferenceForm::value_block_count>
|
|
distinctValueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, DistinctResidualReferenceForm::residual_block_count>
|
|
distinctResidualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
CHECK_THROWS_WITH(
|
|
DistinctResidualReferenceManifest(
|
|
distinctValueSizes,
|
|
distinctResidualSizes,
|
|
nonFiniteResidualReferenceModel,
|
|
3
|
|
),
|
|
"An equilibrium-system manifest constraint requires a finite, positive residual scale."
|
|
);
|
|
|
|
/*
|
|
* This adversarial target is non-finite when the generated residual block
|
|
* obtains its scale, then finite when the constraint descriptor is built.
|
|
* It independently verifies the final block-scale guard rather than
|
|
* reaching the target guard twice for the same NaN.
|
|
*/
|
|
const auto inconsistentScaleModel = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockInconsistentManifestScale({
|
|
.first = std::numeric_limits<double>::quiet_NaN(),
|
|
.subsequent = 2.0
|
|
})
|
|
);
|
|
STATIC_CHECK(std::same_as<
|
|
std::remove_cvref_t<decltype(inconsistentScaleModel)>,
|
|
InconsistentScaleModel>);
|
|
const std::array<int, InconsistentScaleForm::value_block_count> inconsistentValueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, InconsistentScaleForm::residual_block_count> inconsistentResidualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
|
|
CHECK_THROWS_WITH(
|
|
InconsistentScaleManifest(
|
|
inconsistentValueSizes,
|
|
inconsistentResidualSizes,
|
|
inconsistentScaleModel,
|
|
3
|
|
),
|
|
"An equilibrium-system manifest block requires a finite, positive scale."
|
|
);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Manifest Lookup Uses Role And Stable Name Together",
|
|
"[root-manifest][identity][type-contract]"
|
|
) {
|
|
using namespace mean_field;
|
|
constexpr auto surfaceKey = models::SpecificationTraits<surface::Isobaric>::key;
|
|
constexpr auto invariantKey = models::SpecificationTraits<MockInvariantNamedLikeSurface>::key;
|
|
|
|
STATIC_CHECK(surfaceKey.stableName == invariantKey.stableName);
|
|
STATIC_CHECK(surfaceKey.role != invariantKey.role);
|
|
STATIC_CHECK(models::specificationKeysAreUnique<surface::Isobaric, MockInvariantNamedLikeSurface>);
|
|
STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<CrossRoleNameCollisionModel>);
|
|
STATIC_CHECK(operators::CompilableRootManifestFor<CrossRoleNameCollisionModel, CrossRoleNameCollisionForm>);
|
|
|
|
const auto model = model::StellarModel(
|
|
eos::Polytrope({.n = 1.0, .K = 0.25}),
|
|
surface::Isobaric({.Psurf = dimensions::PressureValue{0.125}}),
|
|
integral::FixedTotalMass({.Mtotal = dimensions::MassValue{2.5}}),
|
|
MockInvariantNamedLikeSurface({.target = dimensions::SpecificEnergyValue{7.5}})
|
|
);
|
|
const std::array<int, CrossRoleNameCollisionForm::value_block_count> valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, CrossRoleNameCollisionForm::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const CrossRoleNameCollisionManifest manifest(valueSizes, residualSizes, model, 3);
|
|
|
|
const auto &surfaceDescriptor = manifest.specification<surface::Isobaric>();
|
|
const auto &invariantDescriptor = manifest.specification<MockInvariantNamedLikeSurface>();
|
|
CHECK(surfaceDescriptor.stableId == "IsobaricSurface");
|
|
CHECK(invariantDescriptor.stableId == "IsobaricSurface");
|
|
CHECK(surfaceDescriptor.role == models::SpecificationRole::boundary_condition);
|
|
CHECK(invariantDescriptor.role == models::SpecificationRole::invariant);
|
|
CHECK(surfaceDescriptor.target == 0.125);
|
|
CHECK(invariantDescriptor.target == 7.5);
|
|
CHECK(invariantDescriptor.valueBlock == 6);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Model Values Are Stored In Canonical Specification Order",
|
|
tags::model_specification_type_contract
|
|
) {
|
|
STATIC_CHECK(std::same_as<CanonicalModel, PermutedModel>);
|
|
STATIC_CHECK(CanonicalModel::symbolicallySquare);
|
|
STATIC_CHECK(CanonicalModel::hasCompleteEquilibriumDeclaration);
|
|
STATIC_CHECK(mean_field::operators::StellarEquilibriumSystemCompilable<CanonicalModel>);
|
|
STATIC_CHECK(CentralDensityModel::symbolicallySquare);
|
|
STATIC_CHECK(CentralDensityModel::hasCompleteEquilibriumDeclaration);
|
|
STATIC_CHECK(mean_field::operators::StellarEquilibriumSystemCompilable<CentralDensityModel>);
|
|
|
|
const mean_field::eos::Polytrope equationOfState{2.0, 0.75};
|
|
const mean_field::surface::Isobaric surface{mean_field::dimensions::PressureValue{0.125}};
|
|
const mean_field::models::FixedTotalMass mass{mean_field::dimensions::MassValue{1.75}};
|
|
|
|
const CanonicalModel model{mass, surface, equationOfState};
|
|
|
|
CHECK(model.specification<mean_field::eos::Polytrope>().polytropic_index() == 2.0);
|
|
CHECK(model.specification<mean_field::surface::Isobaric>().targetPressure().value() == 0.125);
|
|
CHECK(
|
|
model.specification<mean_field::models::FixedTotalMass>().targetMass() ==
|
|
mean_field::dimensions::MassValue{1.75}
|
|
);
|
|
|
|
const auto descriptors = model.runtimeSpecificationDescriptors();
|
|
REQUIRE(descriptors.size() == 3);
|
|
CHECK(descriptors[0].specification.name == "Polytrope");
|
|
CHECK(descriptors[1].specification.name == "IsobaricSurface");
|
|
CHECK(descriptors[2].specification.name == "FixedTotalMass");
|
|
CHECK(descriptors[0].canonicalIndex == 0);
|
|
CHECK(descriptors[1].canonicalIndex == 1);
|
|
CHECK(descriptors[2].canonicalIndex == 2);
|
|
CHECK(descriptors[0].hasDeclarativeDefinition);
|
|
CHECK(descriptors[1].hasDeclarativeDefinition);
|
|
CHECK(descriptors[2].hasDeclarativeDefinition);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Fixed Angular Momentum Manifest Appends A Generated Physical Coordinate And Invariant Row",
|
|
tags::root_manifest_type_contract
|
|
) {
|
|
using namespace mean_field;
|
|
const std::array<int, AngularMomentumForm::value_block_count> valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, AngularMomentumForm::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const AngularMomentumModel model(
|
|
eos::Polytrope{1.0, 0.25},
|
|
surface::Isobaric{dimensions::PressureValue{0.125}},
|
|
models::FixedTotalMass{dimensions::MassValue{2.5}},
|
|
models::FixedAngularMomentum{dimensions::AngularMomentumValue{7.5}}
|
|
);
|
|
const AngularMomentumManifest manifest(valueSizes, residualSizes, model, 3);
|
|
|
|
STATIC_CHECK(AngularMomentumForm::value_block_count == 7);
|
|
STATIC_CHECK(AngularMomentumForm::residual_block_count == 7);
|
|
REQUIRE(manifest.valueBlocks().size() == 7);
|
|
REQUIRE(manifest.residualBlocks().size() == 7);
|
|
CHECK(manifest.layout().value_offsets().Last() == 22);
|
|
CHECK(manifest.layout().residual_offsets().Last() == 22);
|
|
CHECK(manifest.valueBlocks()[6].stableId == "fixed_angular_momentum.angular_velocity");
|
|
CHECK(manifest.valueBlocks()[6].symbol == "Omega");
|
|
CHECK(manifest.valueBlocks()[6].columnPolicy ==
|
|
operators::RootColumnPolicy::generated_physical_coordinate);
|
|
CHECK(manifest.residualBlocks()[6].stableId == "fixed_angular_momentum.residual");
|
|
CHECK(manifest.residualBlocks()[6].symbol == "R_J");
|
|
CHECK(manifest.residualBlocks()[6].scale == 7.5);
|
|
|
|
const auto constraints = manifest.constraints();
|
|
REQUIRE(constraints.size() == 3);
|
|
CHECK(constraints[2].stableId == "FixedAngularMomentum");
|
|
CHECK(constraints[2].role == models::SpecificationRole::invariant);
|
|
CHECK(constraints[2].valueBlock == 6);
|
|
CHECK(constraints[2].residualBlock == 6);
|
|
CHECK(constraints[2].rowArity == 1);
|
|
CHECK(constraints[2].columnArity == 1);
|
|
CHECK(constraints[2].target == 7.5);
|
|
CHECK_FALSE(constraints[2].carrierTarget.has_value());
|
|
CHECK(constraints[2].targetUnits == "angular_momentum");
|
|
CHECK(constraints[2].residualScale == 7.5);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Central Density Root Manifest Appends A Carrier Phase Row And Solver Border",
|
|
tags::root_manifest_type_contract
|
|
) {
|
|
STATIC_CHECK(mean_field::operators::CompilableRootManifestFor<CentralDensityModel, CentralForm>);
|
|
|
|
const std::array<int, CentralForm::value_block_count> valueSizes{2, 3, 4, 5, 6, 1, 1};
|
|
const std::array<int, CentralForm::residual_block_count> residualSizes{4, 5, 2, 3, 6, 1, 1};
|
|
const CentralDensityModel model{
|
|
mean_field::eos::Polytrope{1.0, 0.125},
|
|
mean_field::surface::Isobaric{mean_field::dimensions::PressureValue{0.125}},
|
|
mean_field::models::FixedTotalMass{mean_field::dimensions::MassValue{2.5}},
|
|
mean_field::models::FixedCentralDensity{mean_field::dimensions::DensityValue{8.0}}
|
|
};
|
|
const CentralManifest manifest(valueSizes, residualSizes, model, 3);
|
|
|
|
CHECK(manifest.layout().value_offsets().Last() == 22);
|
|
CHECK(manifest.layout().residual_offsets().Last() == 22);
|
|
REQUIRE(manifest.valueBlocks().size() == 7);
|
|
REQUIRE(manifest.residualBlocks().size() == 7);
|
|
CHECK(manifest.valueBlocks()[6].stableId == "fixed_central_density.border");
|
|
CHECK(manifest.valueBlocks()[6].symbol == "lambda_rho_c");
|
|
CHECK(manifest.valueBlocks()[6].columnPolicy == mean_field::operators::RootColumnPolicy::solver_border);
|
|
CHECK(manifest.residualBlocks()[6].stableId == "fixed_central_density.residual");
|
|
CHECK(manifest.residualBlocks()[6].symbol == "R_rho_c");
|
|
CHECK(manifest.residualBlocks()[6].scale == 2.0);
|
|
|
|
const auto constraints = manifest.constraints();
|
|
REQUIRE(constraints.size() == 3);
|
|
CHECK(constraints[2].stableId == "FixedCentralDensity");
|
|
CHECK(constraints[2].role == mean_field::models::SpecificationRole::phase_condition);
|
|
CHECK(constraints[2].valueBlock == 6);
|
|
CHECK(constraints[2].residualBlock == 6);
|
|
CHECK(constraints[2].target == 8.0);
|
|
REQUIRE(constraints[2].carrierTarget.has_value());
|
|
CHECK(*constraints[2].carrierTarget == 2.0);
|
|
CHECK(constraints[2].residualScale == 2.0);
|
|
|
|
CHECK(manifest.specification<mean_field::surface::Isobaric>().target == 0.125);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Compiled Root Manifest Centralizes Canonical Blocks Provenance And Scaling",
|
|
tags::root_manifest_type_contract
|
|
) {
|
|
const Manifest manifest = make_manifest();
|
|
|
|
STATIC_CHECK(Manifest::symbolicallySquare);
|
|
STATIC_CHECK(Manifest::compilationClass == mean_field::models::ModelCompilationClass::isolated_root);
|
|
STATIC_CHECK(mean_field::operators::RootManifestSpecificationDescriptorFor<
|
|
mean_field::models::FixedTotalMass,
|
|
CanonicalModel>);
|
|
STATIC_CHECK(mean_field::operators::RootManifestSpecificationDescriptorFor<
|
|
mean_field::surface::Isobaric,
|
|
CanonicalModel>);
|
|
STATIC_CHECK_FALSE(mean_field::operators::RootManifestSpecificationDescriptorFor<
|
|
mean_field::eos::Polytrope,
|
|
CanonicalModel>);
|
|
STATIC_CHECK(HasRootManifestSpecificationDescriptor<
|
|
Manifest,
|
|
mean_field::models::FixedTotalMass>);
|
|
STATIC_CHECK(HasRootManifestSpecificationDescriptor<Manifest, mean_field::surface::Isobaric>);
|
|
STATIC_CHECK_FALSE(HasRootManifestSpecificationDescriptor<Manifest, mean_field::eos::Polytrope>);
|
|
STATIC_CHECK_FALSE(CanMutateManifestBlock<
|
|
typename Manifest::StateView,
|
|
decltype(mean_field::utils::blocks::density_field.mass_term)>);
|
|
STATIC_CHECK_FALSE(CanMutateManifestBlock<
|
|
typename Manifest::DirectionView,
|
|
decltype(mean_field::utils::blocks::density_field.mass_term)>);
|
|
STATIC_CHECK(CanMutateManifestBlock<
|
|
typename Manifest::MutableStateView,
|
|
decltype(mean_field::utils::blocks::density_field.mass_term)>);
|
|
|
|
CHECK(manifest.layout().value_offsets().Last() == 21);
|
|
CHECK(manifest.layout().residual_offsets().Last() == 21);
|
|
|
|
const auto values = manifest.valueBlocks();
|
|
const auto residuals = manifest.residualBlocks();
|
|
|
|
REQUIRE(values.size() == 6);
|
|
REQUIRE(residuals.size() == 6);
|
|
CHECK(values[0].stableId == "density");
|
|
CHECK(values[0].symbol == "rho");
|
|
CHECK(values[1].stableId == "surface_deformation");
|
|
CHECK(values[5].stableId == "fixed_total_mass.multiplier");
|
|
CHECK(values[5].symbol == "C");
|
|
CHECK(values[5].provenance == mean_field::operators::RootBlockProvenance::model_specification);
|
|
CHECK(values[5].source == "FixedTotalMass");
|
|
CHECK(values[5].columnPolicy == mean_field::operators::RootColumnPolicy::existing_physical_multiplier);
|
|
|
|
CHECK(residuals[5].stableId == "fixed_total_mass.residual");
|
|
CHECK(residuals[5].symbol == "R_M");
|
|
CHECK(residuals[5].rowInjection == mean_field::operators::RootRowInjection::append_global);
|
|
CHECK(residuals[5].scalePolicy == mean_field::operators::RootScalePolicy::target_relative);
|
|
CHECK(residuals[5].scale == 2.5);
|
|
|
|
const auto replacements = manifest.rowReplacements();
|
|
REQUIRE(replacements.size() == 1);
|
|
CHECK(replacements[0].sourceSpecification == "IsobaricSurface");
|
|
CHECK(replacements[0].replacedRowCount == 3);
|
|
CHECK(replacements[0].carrierResidualBlock == 4);
|
|
|
|
const auto constraints = manifest.constraints();
|
|
REQUIRE(constraints.size() == 2);
|
|
const auto &massConstraint = manifest.specification<mean_field::models::FixedTotalMass>();
|
|
CHECK(massConstraint.stableId == "FixedTotalMass");
|
|
CHECK(massConstraint.valueBlock == 5);
|
|
CHECK(massConstraint.residualBlock == 5);
|
|
CHECK(massConstraint.target == 2.5);
|
|
CHECK(massConstraint.residualScale == 2.5);
|
|
const auto &surfaceConstraint = manifest.specification<mean_field::surface::Isobaric>();
|
|
CHECK(surfaceConstraint.stableId == "IsobaricSurface");
|
|
CHECK(surfaceConstraint.rowInjection == mean_field::operators::RootRowInjection::replace_carrier_rows);
|
|
CHECK(surfaceConstraint.target == 0.125);
|
|
CHECK_FALSE(surfaceConstraint.carrierTarget.has_value());
|
|
|
|
const auto report = manifest.fixedMassReport(2.75);
|
|
CHECK(report.achieved == 2.75);
|
|
CHECK(report.dimensionalResidual == 0.25);
|
|
CHECK(report.scaledResidual == 0.1);
|
|
}
|
|
|
|
TEST_CASE(
|
|
"Typed Root Views Resolve Blocks Through The Compiled Manifest",
|
|
tags::root_manifest_type_contract
|
|
) {
|
|
const Manifest manifest = make_manifest();
|
|
|
|
STATIC_CHECK(HasLvalueRootViewFactories<Manifest>);
|
|
STATIC_CHECK_FALSE(StateViewAcceptsTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(StateViewAcceptsConstTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(DirectionViewAcceptsTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(DirectionViewAcceptsConstTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(ResidualViewAcceptsTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(ResidualViewAcceptsConstTemporaryVector<Manifest>);
|
|
STATIC_CHECK_FALSE(TemporaryManifestProvidesStateView<Manifest>);
|
|
STATIC_CHECK_FALSE(TemporaryManifestProvidesReadOnlyStateView<Manifest>);
|
|
STATIC_CHECK_FALSE(TemporaryManifestProvidesDirectionView<Manifest>);
|
|
STATIC_CHECK_FALSE(TemporaryManifestProvidesResidualView<Manifest>);
|
|
|
|
STATIC_CHECK(std::constructible_from<
|
|
typename Manifest::StateView,
|
|
const mfem::Vector &,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK(std::constructible_from<
|
|
typename Manifest::MutableStateView,
|
|
mfem::Vector &,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK(std::constructible_from<
|
|
typename Manifest::RootResidualView,
|
|
mfem::Vector &,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::StateView,
|
|
mfem::Vector &&,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::StateView,
|
|
const mfem::Vector &&,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::MutableStateView,
|
|
mfem::Vector &&,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::RootResidualView,
|
|
mfem::Vector &&,
|
|
const typename Manifest::Layout &>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::StateView,
|
|
const mfem::Vector &,
|
|
typename Manifest::Layout &&>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::MutableStateView,
|
|
mfem::Vector &,
|
|
typename Manifest::Layout &&>);
|
|
STATIC_CHECK_FALSE(std::constructible_from<
|
|
typename Manifest::RootResidualView,
|
|
mfem::Vector &,
|
|
typename Manifest::Layout &&>);
|
|
|
|
mfem::Vector state(manifest.layout().value_offsets().Last());
|
|
for (int index = 0; index < state.Size(); ++index) {
|
|
state(index) = static_cast<double>(index + 1);
|
|
}
|
|
|
|
const auto stateView = manifest.stateView(state);
|
|
const mfem::Vector density = stateView.block(mean_field::utils::blocks::density_field.mass_term);
|
|
const mfem::Vector surface = stateView.block(mean_field::utils::blocks::surface_deformation_field.parameters_term);
|
|
const mfem::Vector multiplier =
|
|
stateView.block(mean_field::utils::blocks::fixed_total_mass_constraint.mass_normalization_term);
|
|
|
|
REQUIRE(density.Size() == 2);
|
|
REQUIRE(surface.Size() == 3);
|
|
REQUIRE(multiplier.Size() == 1);
|
|
CHECK(density(0) == 1.0);
|
|
CHECK(surface(0) == 3.0);
|
|
CHECK(multiplier(0) == 21.0);
|
|
|
|
mfem::Vector residual(manifest.layout().residual_offsets().Last());
|
|
residual = 0.0;
|
|
const auto residualView = manifest.residualView(residual);
|
|
mfem::Vector massResidual(1);
|
|
massResidual(0) = -0.375;
|
|
residualView.assign(mean_field::utils::blocks::fixed_total_mass_constraint.mass_normalization_term, massResidual);
|
|
CHECK(residual(20) == -0.375);
|
|
|
|
mfem::Vector wrongState(state.Size() - 1);
|
|
CHECK_THROWS_AS(manifest.stateView(wrongState), std::invalid_argument);
|
|
}
|