1554 lines
70 KiB
C++
1554 lines
70 KiB
C++
module;
|
|
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <compare>
|
|
#include <concepts>
|
|
#include <cstddef>
|
|
#include <format>
|
|
#include <span>
|
|
#include <stdexcept>
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
export module mean_field:model.specifications;
|
|
|
|
export import :eos.polytrope;
|
|
export import :surface.constant;
|
|
|
|
export namespace mean_field::models {
|
|
enum class SpecificationRole {
|
|
constitutive_law,
|
|
boundary_condition,
|
|
invariant,
|
|
phase_condition,
|
|
gauge_choice,
|
|
rotation_law
|
|
};
|
|
|
|
/*
|
|
* The small declarations in this section are the physics-facing model
|
|
* extension API. A specification owns one nested ModelDefinition and the
|
|
* compiler projects the lower-level traits from it. Extension authors do
|
|
* not specialize a registry or choose a globally coordinated ordinal.
|
|
*/
|
|
template <std::size_t Extent> struct FixedString final {
|
|
char characters[Extent]{};
|
|
|
|
consteval FixedString(const char (&text)[Extent]) noexcept {
|
|
for (std::size_t index = 0; index < Extent; ++index) {
|
|
characters[index] = text[index];
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] constexpr std::string_view view() const noexcept {
|
|
static_assert(Extent > 0);
|
|
return {characters, Extent - 1};
|
|
}
|
|
|
|
constexpr bool operator==(const FixedString &) const = default;
|
|
};
|
|
|
|
template <std::size_t Extent> FixedString(const char (&)[Extent]) -> FixedString<Extent>;
|
|
|
|
template <typename... Types> struct ModelTypeList final {
|
|
static constexpr std::size_t size = sizeof...(Types);
|
|
};
|
|
|
|
template <typename... ValueBlocks> using DependsOn = ModelTypeList<ValueBlocks...>;
|
|
|
|
template <typename... ResidualBlocks> using Affects = ModelTypeList<ResidualBlocks...>;
|
|
|
|
/*
|
|
* Physics vocabulary for declaring how a stellar specification couples to
|
|
* the equilibrium system. These names deliberately do not import the
|
|
* solver's block registry: the operator compiler translates them once at
|
|
* its backend boundary. Advanced extensions may still place an existing
|
|
* backend block type directly in DependsOn/Affects.
|
|
*/
|
|
namespace stellar {
|
|
namespace state {
|
|
struct Density final { };
|
|
struct SurfaceShape final { };
|
|
struct GravityGradient final { };
|
|
struct GravitationalPotential final { };
|
|
struct SpecificEnthalpy final { };
|
|
|
|
/*
|
|
* A coordinate generated by another named specification. This is
|
|
* the physics-facing spelling for coupled global constraints: an
|
|
* extension names the constraint it reads, never its solver block.
|
|
*/
|
|
template <typename Specification> struct GeneratedCoordinateOf final {
|
|
using SpecificationType = Specification;
|
|
};
|
|
|
|
/*
|
|
* The coordinate generated by the specification containing this
|
|
* marker. For example, FixedAngularMomentum uses it to state that
|
|
* its integral residual depends on angular velocity without naming
|
|
* a generated solver block.
|
|
*/
|
|
struct OwnGeneratedCoordinate final { };
|
|
} // namespace state
|
|
|
|
namespace equation {
|
|
struct GravityGradientDefinition final { };
|
|
struct PoissonEquation final { };
|
|
struct DensityClosure final { };
|
|
struct SurfaceShapeBalance final { };
|
|
struct HydrostaticBalance final { };
|
|
|
|
/* The scalar constraint equation owned by this specification. */
|
|
struct OwnConstraint final { };
|
|
|
|
/* The scalar constraint equation owned by another specification. */
|
|
template <typename Specification> struct ConstraintOf final {
|
|
using SpecificationType = Specification;
|
|
};
|
|
} // namespace equation
|
|
|
|
/*
|
|
* A readable, compile-time label for one declared Jacobian derivative.
|
|
* Runtime providers consume this vocabulary without learning backend
|
|
* row and column block types.
|
|
*/
|
|
template <typename Equation, typename State> struct Derivative final {
|
|
using EquationType = Equation;
|
|
using StateType = State;
|
|
};
|
|
} // namespace stellar
|
|
|
|
enum class GeneratedStateKind { none, multiplier, physical_coordinate, solver_border };
|
|
|
|
enum class RieszTopology {
|
|
unavailable,
|
|
identity,
|
|
scalar_volume_l2,
|
|
vector_volume_l2,
|
|
scalar_boundary_l2,
|
|
hybrid_scalar_volume_point_rows,
|
|
global_scalar
|
|
};
|
|
|
|
enum class PhysicalScaleLaw {
|
|
unavailable,
|
|
dimensionless,
|
|
density,
|
|
length,
|
|
acceleration,
|
|
inverse_time_squared,
|
|
specific_energy,
|
|
pressure,
|
|
mass,
|
|
force,
|
|
angular_velocity,
|
|
angular_momentum
|
|
};
|
|
|
|
/*
|
|
* PhysicalScaleLaw is the numerical scaling vocabulary, while the
|
|
* dimensions module carries the authoritative semantic quantity types.
|
|
* Keep their relationship in one extensible trait so a physics-facing
|
|
* scalar declaration cannot spell a quantity in one place and an
|
|
* unrelated normalization scale somewhere else.
|
|
*/
|
|
template <typename Quantity> struct PhysicalScaleForQuantity {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::unavailable;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Dimensionless> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::dimensionless;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Mass> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::mass;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Length> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::length;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Density> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::density;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Acceleration> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::acceleration;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::SpecificEnergy> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::specific_energy;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::SpecificEnthalpy> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::specific_energy;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::GravitationalPotential> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::specific_energy;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Pressure> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::pressure;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::Force> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::force;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::AngularVelocity> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::angular_velocity;
|
|
};
|
|
|
|
template <> struct PhysicalScaleForQuantity<dimensions::quantity::AngularMomentum> {
|
|
static constexpr PhysicalScaleLaw value = PhysicalScaleLaw::angular_momentum;
|
|
};
|
|
|
|
template <typename Quantity>
|
|
inline constexpr PhysicalScaleLaw physicalScaleForQuantity =
|
|
PhysicalScaleForQuantity<std::remove_cv_t<Quantity>>::value;
|
|
|
|
template <typename Quantity>
|
|
concept PhysicalScaleRepresentedQuantity =
|
|
dimensions::PhysicalQuantityType<Quantity> &&
|
|
physicalScaleForQuantity<Quantity> != PhysicalScaleLaw::unavailable &&
|
|
requires { typename std::bool_constant<!static_cast<std::string_view>(Quantity::identifier).empty()>; };
|
|
|
|
namespace detail {
|
|
template <typename Candidate> [[nodiscard]] consteval bool declaredCoordinateNormalizationIsAvailable() {
|
|
if constexpr (requires {
|
|
{ Candidate::available } -> std::convertible_to<bool>;
|
|
}) {
|
|
return static_cast<bool>(Candidate::available);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] consteval bool isKnownSpecificationRole(const SpecificationRole role) {
|
|
switch (role) {
|
|
case SpecificationRole::constitutive_law:
|
|
case SpecificationRole::boundary_condition:
|
|
case SpecificationRole::invariant:
|
|
case SpecificationRole::phase_condition:
|
|
case SpecificationRole::gauge_choice:
|
|
case SpecificationRole::rotation_law:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] consteval bool isKnownGeneratedStateKind(const GeneratedStateKind kind) {
|
|
switch (kind) {
|
|
case GeneratedStateKind::none:
|
|
case GeneratedStateKind::multiplier:
|
|
case GeneratedStateKind::physical_coordinate:
|
|
case GeneratedStateKind::solver_border:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] consteval bool specificationRoleAcceptsGeneratedStateKind(
|
|
const SpecificationRole role,
|
|
const GeneratedStateKind kind
|
|
) {
|
|
switch (role) {
|
|
case SpecificationRole::constitutive_law:
|
|
case SpecificationRole::boundary_condition:
|
|
return kind == GeneratedStateKind::none;
|
|
case SpecificationRole::invariant:
|
|
return kind == GeneratedStateKind::multiplier || kind == GeneratedStateKind::physical_coordinate;
|
|
case SpecificationRole::phase_condition:
|
|
case SpecificationRole::gauge_choice:
|
|
return kind == GeneratedStateKind::solver_border;
|
|
case SpecificationRole::rotation_law:
|
|
/*
|
|
* Rotation laws currently prescribe a physical profile; they
|
|
* do not own a root coordinate. Fixed angular momentum owns
|
|
* angular velocity as an invariant/physical-coordinate pair.
|
|
* Keep this closed until a state-generating rotation-law
|
|
* contract is designed and implemented end to end.
|
|
*/
|
|
return kind == GeneratedStateKind::none;
|
|
}
|
|
return false;
|
|
}
|
|
} // namespace detail
|
|
|
|
template <SpecificationRole Role, GeneratedStateKind StateKind>
|
|
concept CompatibleSpecificationRoleAndGeneratedState =
|
|
detail::isKnownSpecificationRole(Role) && detail::isKnownGeneratedStateKind(StateKind) &&
|
|
detail::specificationRoleAcceptsGeneratedStateKind(Role, StateKind);
|
|
|
|
template <RieszTopology Topology, PhysicalScaleLaw Scale> struct CoordinateNormalization final {
|
|
static constexpr RieszTopology topology = Topology;
|
|
static constexpr PhysicalScaleLaw scale = Scale;
|
|
static constexpr bool available =
|
|
topology != RieszTopology::unavailable && scale != PhysicalScaleLaw::unavailable;
|
|
};
|
|
|
|
using UnavailableCoordinateNormalization =
|
|
CoordinateNormalization<RieszTopology::unavailable, PhysicalScaleLaw::unavailable>;
|
|
|
|
template <
|
|
typename ValueNormalization = UnavailableCoordinateNormalization,
|
|
typename ResidualNormalization = UnavailableCoordinateNormalization>
|
|
struct GeneratedNormalization final {
|
|
using Value = ValueNormalization;
|
|
using Residual = ResidualNormalization;
|
|
|
|
static constexpr bool available = detail::declaredCoordinateNormalizationIsAvailable<Value>() &&
|
|
detail::declaredCoordinateNormalizationIsAvailable<Residual>();
|
|
};
|
|
|
|
using UnavailableGeneratedNormalization = GeneratedNormalization<>;
|
|
|
|
template <PhysicalScaleLaw ValueScale, PhysicalScaleLaw ResidualScale>
|
|
using GlobalScalarNormalization = GeneratedNormalization<
|
|
CoordinateNormalization<RieszTopology::global_scalar, ValueScale>,
|
|
CoordinateNormalization<RieszTopology::global_scalar, ResidualScale>>;
|
|
|
|
template <
|
|
FixedString ValueStableId = "",
|
|
FixedString ValueSymbol = "",
|
|
FixedString ResidualStableId = "",
|
|
FixedString ResidualSymbol = "",
|
|
FixedString TargetUnits = "",
|
|
FixedString ResidualUnits = "">
|
|
struct GeneratedManifest final {
|
|
private:
|
|
inline static constexpr auto valueStableIdStorage = ValueStableId;
|
|
inline static constexpr auto valueSymbolStorage = ValueSymbol;
|
|
inline static constexpr auto residualStableIdStorage = ResidualStableId;
|
|
inline static constexpr auto residualSymbolStorage = ResidualSymbol;
|
|
inline static constexpr auto targetUnitsStorage = TargetUnits;
|
|
inline static constexpr auto residualUnitsStorage = ResidualUnits;
|
|
|
|
public:
|
|
static constexpr std::string_view valueStableId = valueStableIdStorage.view();
|
|
static constexpr std::string_view valueSymbol = valueSymbolStorage.view();
|
|
static constexpr std::string_view residualStableId = residualStableIdStorage.view();
|
|
static constexpr std::string_view residualSymbol = residualSymbolStorage.view();
|
|
static constexpr std::string_view targetUnits = targetUnitsStorage.view();
|
|
static constexpr std::string_view residualUnits = residualUnitsStorage.view();
|
|
static constexpr bool available = !valueStableId.empty() && !valueSymbol.empty() && !residualStableId.empty() &&
|
|
!residualSymbol.empty() && !targetUnits.empty() && !residualUnits.empty();
|
|
};
|
|
|
|
using UnavailableGeneratedManifest = GeneratedManifest<>;
|
|
|
|
/*
|
|
* A scalar constraint has three independent dimensional statements:
|
|
*
|
|
* - the physical quantity supplied as its target;
|
|
* - the generated Newton coordinate; and
|
|
* - the appended scalar residual.
|
|
*
|
|
* They are deliberately not equated. FixedCentralDensity, for example,
|
|
* has a density target but a specific-enthalpy phase residual. The
|
|
* quantity types below generate both numerical scale laws and diagnostic
|
|
* unit labels, making the strings presentation rather than authority.
|
|
*/
|
|
template <
|
|
PhysicalScaleRepresentedQuantity TargetQuantityT,
|
|
PhysicalScaleRepresentedQuantity GeneratedCoordinateQuantityT,
|
|
PhysicalScaleRepresentedQuantity ConstraintResidualQuantityT,
|
|
FixedString ValueStableId,
|
|
FixedString ValueSymbol,
|
|
FixedString ResidualStableId,
|
|
FixedString ResidualSymbol>
|
|
struct DimensionalScalarConstraint final {
|
|
using TargetQuantity = TargetQuantityT;
|
|
using GeneratedCoordinateQuantity = GeneratedCoordinateQuantityT;
|
|
using ConstraintResidualQuantity = ConstraintResidualQuantityT;
|
|
using TargetValue = dimensions::QuantityValue<TargetQuantity>;
|
|
static constexpr PhysicalScaleLaw targetScale = physicalScaleForQuantity<TargetQuantity>;
|
|
|
|
struct Normalization final {
|
|
using TargetQuantity = TargetQuantityT;
|
|
using GeneratedCoordinateQuantity = GeneratedCoordinateQuantityT;
|
|
using ConstraintResidualQuantity = ConstraintResidualQuantityT;
|
|
using TargetValue = dimensions::QuantityValue<TargetQuantity>;
|
|
static constexpr PhysicalScaleLaw targetScale = physicalScaleForQuantity<TargetQuantity>;
|
|
using Value = CoordinateNormalization<
|
|
RieszTopology::global_scalar,
|
|
physicalScaleForQuantity<GeneratedCoordinateQuantity>>;
|
|
using Residual = CoordinateNormalization<
|
|
RieszTopology::global_scalar,
|
|
physicalScaleForQuantity<ConstraintResidualQuantity>>;
|
|
|
|
static constexpr bool available = Value::available && Residual::available;
|
|
};
|
|
|
|
struct Manifest final {
|
|
using TargetQuantity = TargetQuantityT;
|
|
using GeneratedCoordinateQuantity = GeneratedCoordinateQuantityT;
|
|
using ConstraintResidualQuantity = ConstraintResidualQuantityT;
|
|
|
|
private:
|
|
inline static constexpr auto valueStableIdStorage = ValueStableId;
|
|
inline static constexpr auto valueSymbolStorage = ValueSymbol;
|
|
inline static constexpr auto residualStableIdStorage = ResidualStableId;
|
|
inline static constexpr auto residualSymbolStorage = ResidualSymbol;
|
|
|
|
public:
|
|
static constexpr std::string_view valueStableId = valueStableIdStorage.view();
|
|
static constexpr std::string_view valueSymbol = valueSymbolStorage.view();
|
|
static constexpr std::string_view residualStableId = residualStableIdStorage.view();
|
|
static constexpr std::string_view residualSymbol = residualSymbolStorage.view();
|
|
static constexpr std::string_view targetUnits = TargetQuantity::identifier;
|
|
static constexpr std::string_view residualUnits = ConstraintResidualQuantity::identifier;
|
|
static constexpr bool available = !valueStableId.empty() && !valueSymbol.empty() &&
|
|
!residualStableId.empty() && !residualSymbol.empty() &&
|
|
!targetUnits.empty() && !residualUnits.empty();
|
|
};
|
|
|
|
static constexpr bool dimensionallyTyped = true;
|
|
};
|
|
|
|
template <
|
|
typename Specification,
|
|
FixedString StableName,
|
|
SpecificationRole Role,
|
|
GeneratedStateKind StateKind = GeneratedStateKind::none,
|
|
typename DependsOnBlocks = ModelTypeList<>,
|
|
typename AffectedResidualBlocks = ModelTypeList<>,
|
|
typename NormalizationDefinition = UnavailableGeneratedNormalization,
|
|
typename ManifestDefinition = UnavailableGeneratedManifest>
|
|
struct ModelDefinition final {
|
|
using SpecificationType = Specification;
|
|
using DependsOn = DependsOnBlocks;
|
|
using Affects = AffectedResidualBlocks;
|
|
using Normalization = NormalizationDefinition;
|
|
using Manifest = ManifestDefinition;
|
|
|
|
private:
|
|
inline static constexpr auto stableNameStorage = StableName;
|
|
|
|
public:
|
|
static constexpr std::string_view name = stableNameStorage.view();
|
|
static constexpr SpecificationRole role = Role;
|
|
static constexpr GeneratedStateKind generatedStateKind = StateKind;
|
|
static constexpr std::size_t generatedValueArity = StateKind == GeneratedStateKind::none ? 0U : 1U;
|
|
static constexpr std::size_t generatedResidualArity = StateKind == GeneratedStateKind::none ? 0U : 1U;
|
|
static constexpr bool structurallyAvailable = !name.empty();
|
|
};
|
|
|
|
template <typename Specification, FixedString Name>
|
|
using ConstitutiveLaw = ModelDefinition<Specification, Name, SpecificationRole::constitutive_law>;
|
|
|
|
template <typename Specification, FixedString Name>
|
|
using BoundaryCondition = ModelDefinition<Specification, Name, SpecificationRole::boundary_condition>;
|
|
|
|
template <
|
|
typename Specification,
|
|
FixedString Name,
|
|
typename DependsOn = ModelTypeList<>,
|
|
typename Affects = ModelTypeList<>,
|
|
typename Normalization = UnavailableGeneratedNormalization,
|
|
typename Manifest = UnavailableGeneratedManifest>
|
|
using FixedIntegralWithMultiplier = ModelDefinition<
|
|
Specification,
|
|
Name,
|
|
SpecificationRole::invariant,
|
|
GeneratedStateKind::multiplier,
|
|
DependsOn,
|
|
Affects,
|
|
Normalization,
|
|
Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
FixedString Name,
|
|
typename DependsOn = ModelTypeList<>,
|
|
typename Affects = ModelTypeList<>,
|
|
typename Normalization = UnavailableGeneratedNormalization,
|
|
typename Manifest = UnavailableGeneratedManifest>
|
|
using FixedIntegralWithPhysicalCoordinate = ModelDefinition<
|
|
Specification,
|
|
Name,
|
|
SpecificationRole::invariant,
|
|
GeneratedStateKind::physical_coordinate,
|
|
DependsOn,
|
|
Affects,
|
|
Normalization,
|
|
Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
FixedString Name,
|
|
typename DependsOn = ModelTypeList<>,
|
|
typename Affects = ModelTypeList<>,
|
|
typename Normalization = UnavailableGeneratedNormalization,
|
|
typename Manifest = UnavailableGeneratedManifest>
|
|
using PhaseCondition = ModelDefinition<
|
|
Specification,
|
|
Name,
|
|
SpecificationRole::phase_condition,
|
|
GeneratedStateKind::solver_border,
|
|
DependsOn,
|
|
Affects,
|
|
Normalization,
|
|
Manifest>;
|
|
|
|
struct SpecificationKey final {
|
|
SpecificationRole role;
|
|
GeneratedStateKind generatedStateKind;
|
|
std::string_view stableName;
|
|
|
|
constexpr auto operator<=>(const SpecificationKey &) const = default;
|
|
};
|
|
|
|
struct SpecificationDescriptor final {
|
|
std::string_view name;
|
|
SpecificationRole role;
|
|
SpecificationKey key;
|
|
std::size_t generatedValueArity;
|
|
std::size_t generatedResidualArity;
|
|
|
|
constexpr bool operator==(const SpecificationDescriptor &) const = default;
|
|
};
|
|
|
|
enum class EquilibriumSystemCompilation {
|
|
complete_equilibrium_system,
|
|
equation_contributions_only,
|
|
|
|
// Transitional spellings retained while internal solver code is
|
|
// migrated to physics-facing equilibrium-system terminology.
|
|
isolated_root = complete_equilibrium_system,
|
|
assembly_only = equation_contributions_only
|
|
};
|
|
|
|
using ModelCompilationClass = EquilibriumSystemCompilation;
|
|
|
|
struct RuntimeSpecificationDescriptor final {
|
|
SpecificationDescriptor specification;
|
|
std::size_t canonicalIndex;
|
|
|
|
// This reports only the self-owned physics declaration. Numerical
|
|
// support is queried from the operator compiler for the complete model.
|
|
bool hasDeclarativeDefinition;
|
|
|
|
constexpr bool operator==(const RuntimeSpecificationDescriptor &) const = default;
|
|
};
|
|
|
|
namespace detail {
|
|
template <typename Candidate> struct IsModelTypeList : std::false_type { };
|
|
|
|
template <typename... Types> struct IsModelTypeList<ModelTypeList<Types...>> : std::true_type { };
|
|
|
|
template <typename Candidate> struct IsModelDefinition : std::false_type { };
|
|
|
|
template <
|
|
typename Specification,
|
|
FixedString StableName,
|
|
SpecificationRole Role,
|
|
GeneratedStateKind StateKind,
|
|
typename DependsOn,
|
|
typename Affects,
|
|
typename Normalization,
|
|
typename Manifest>
|
|
struct IsModelDefinition<
|
|
ModelDefinition<Specification, StableName, Role, StateKind, DependsOn, Affects, Normalization, Manifest>>
|
|
: std::bool_constant<
|
|
(StableName.view().size() > 0) && CompatibleSpecificationRoleAndGeneratedState<Role, StateKind> &&
|
|
IsModelTypeList<DependsOn>::value && IsModelTypeList<Affects>::value> { };
|
|
|
|
template <typename Definition, typename Candidate, bool = IsModelDefinition<Definition>::value>
|
|
struct DefinitionDescribesCandidate : std::false_type { };
|
|
|
|
template <typename Definition, typename Candidate>
|
|
struct DefinitionDescribesCandidate<Definition, Candidate, true>
|
|
: std::bool_constant<std::same_as<typename Definition::SpecificationType, Candidate>> { };
|
|
|
|
template <typename Candidate, typename = void> struct SpecificationDefinitionFor {
|
|
static constexpr bool available = false;
|
|
};
|
|
|
|
template <typename Candidate>
|
|
struct SpecificationDefinitionFor<
|
|
Candidate,
|
|
std::void_t<typename std::remove_cvref_t<Candidate>::ModelDefinition>> {
|
|
using Type = typename std::remove_cvref_t<Candidate>::ModelDefinition;
|
|
static constexpr bool available = DefinitionDescribesCandidate<Type, std::remove_cvref_t<Candidate>>::value;
|
|
};
|
|
|
|
// Compatibility projections for the two physical types that predate
|
|
// the self-describing front end. New types use only ModelDefinition.
|
|
template <> struct SpecificationDefinitionFor<eos::Polytrope> {
|
|
using Type = ConstitutiveLaw<eos::Polytrope, "Polytrope">;
|
|
static constexpr bool available = true;
|
|
};
|
|
|
|
template <> struct SpecificationDefinitionFor<surface::ConstantPressureSurface> {
|
|
using Type = BoundaryCondition<surface::ConstantPressureSurface, "IsobaricSurface">;
|
|
static constexpr bool available = true;
|
|
};
|
|
} // namespace detail
|
|
|
|
template <typename Candidate>
|
|
concept SelfDescribingModelSpecification = requires {
|
|
typename std::remove_cvref_t<Candidate>::ModelDefinition;
|
|
} && detail::SpecificationDefinitionFor<std::remove_cvref_t<Candidate>>::available;
|
|
|
|
template <typename Candidate>
|
|
requires detail::SpecificationDefinitionFor<std::remove_cvref_t<Candidate>>::available
|
|
using ModelDefinitionForT = typename detail::SpecificationDefinitionFor<std::remove_cvref_t<Candidate>>::Type;
|
|
|
|
template <typename Candidate> struct SpecificationTraits;
|
|
|
|
template <typename Candidate>
|
|
requires detail::SpecificationDefinitionFor<std::remove_cvref_t<Candidate>>::available
|
|
struct SpecificationTraits<Candidate> {
|
|
using Definition = ModelDefinitionForT<Candidate>;
|
|
|
|
static constexpr std::string_view name = Definition::name;
|
|
static constexpr SpecificationRole role = Definition::role;
|
|
static constexpr SpecificationKey key{role, Definition::generatedStateKind, name};
|
|
};
|
|
|
|
template <typename Candidate>
|
|
concept ModelSpecification =
|
|
detail::SpecificationDefinitionFor<std::remove_cvref_t<Candidate>>::available &&
|
|
requires {
|
|
typename std::remove_cvref_t<Candidate>::Parameters;
|
|
{ SpecificationTraits<std::remove_cvref_t<Candidate>>::name } -> std::convertible_to<std::string_view>;
|
|
{ SpecificationTraits<std::remove_cvref_t<Candidate>>::role } -> std::convertible_to<SpecificationRole>;
|
|
{ SpecificationTraits<std::remove_cvref_t<Candidate>>::key } -> std::convertible_to<SpecificationKey>;
|
|
} &&
|
|
std::constructible_from<std::remove_cvref_t<Candidate>, typename std::remove_cvref_t<Candidate>::Parameters>;
|
|
|
|
class FixedTotalMass final {
|
|
public:
|
|
struct Parameters final {
|
|
dimensions::MassValue Mtotal;
|
|
};
|
|
|
|
using ScalarDescription = DimensionalScalarConstraint<
|
|
dimensions::quantity::Mass,
|
|
dimensions::quantity::SpecificEnergy,
|
|
dimensions::quantity::Mass,
|
|
"fixed_total_mass.multiplier",
|
|
"C",
|
|
"fixed_total_mass.residual",
|
|
"R_M">;
|
|
using TargetValue = typename ScalarDescription::TargetValue;
|
|
using ModelDefinition = FixedIntegralWithMultiplier<
|
|
FixedTotalMass,
|
|
"FixedTotalMass",
|
|
DependsOn<stellar::state::Density, stellar::state::SurfaceShape>,
|
|
Affects<stellar::equation::HydrostaticBalance>,
|
|
typename ScalarDescription::Normalization,
|
|
typename ScalarDescription::Manifest>;
|
|
|
|
explicit FixedTotalMass(const Parameters parameters) : FixedTotalMass(parameters.Mtotal) {
|
|
}
|
|
|
|
explicit FixedTotalMass(const TargetValue targetMass) : m_targetMass(targetMass) {
|
|
if (!std::isfinite(targetMass.value()) || targetMass.value() <= 0.0) {
|
|
throw std::invalid_argument(
|
|
std::format(
|
|
"The fixed total mass must be finite and positive. "
|
|
"Instead M = {} was provided.",
|
|
targetMass.value()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] TargetValue targetMass() const noexcept {
|
|
return m_targetMass;
|
|
}
|
|
|
|
[[nodiscard]] TargetValue target() const noexcept {
|
|
return m_targetMass;
|
|
}
|
|
|
|
private:
|
|
TargetValue m_targetMass;
|
|
};
|
|
|
|
class FixedAngularMomentum final {
|
|
public:
|
|
struct Parameters final {
|
|
dimensions::AngularMomentumValue Jtotal;
|
|
std::array<double, 3> axis{0.0, 0.0, 1.0};
|
|
std::array<double, 3> center{0.0, 0.0, 0.0};
|
|
};
|
|
|
|
using ScalarDescription = DimensionalScalarConstraint<
|
|
dimensions::quantity::AngularMomentum,
|
|
dimensions::quantity::AngularVelocity,
|
|
dimensions::quantity::AngularMomentum,
|
|
"fixed_angular_momentum.angular_velocity",
|
|
"Omega",
|
|
"fixed_angular_momentum.residual",
|
|
"R_J">;
|
|
using TargetValue = typename ScalarDescription::TargetValue;
|
|
using ModelDefinition = FixedIntegralWithPhysicalCoordinate<
|
|
FixedAngularMomentum,
|
|
"FixedAngularMomentum",
|
|
DependsOn<stellar::state::Density, stellar::state::SurfaceShape, stellar::state::OwnGeneratedCoordinate>,
|
|
Affects<stellar::equation::SurfaceShapeBalance, stellar::equation::HydrostaticBalance>,
|
|
typename ScalarDescription::Normalization,
|
|
typename ScalarDescription::Manifest>;
|
|
|
|
explicit FixedAngularMomentum(const Parameters parameters)
|
|
: m_targetAngularMomentum(parameters.Jtotal),
|
|
m_axis(parameters.axis),
|
|
m_center(parameters.center) {
|
|
if (!std::isfinite(m_targetAngularMomentum.value()) || m_targetAngularMomentum.value() < 0.0) {
|
|
throw std::invalid_argument(
|
|
std::format(
|
|
"The fixed total angular momentum must be finite and "
|
|
"nonnegative. Instead J = {} was "
|
|
"provided.",
|
|
m_targetAngularMomentum.value()
|
|
)
|
|
);
|
|
}
|
|
|
|
double axisNormSquared = 0.0;
|
|
for (std::size_t component = 0; component < m_axis.size(); ++component) {
|
|
if (!std::isfinite(m_axis[component]) || !std::isfinite(m_center[component])) {
|
|
throw std::invalid_argument(
|
|
"A fixed-angular-momentum rotation axis and center must contain "
|
|
"only finite values."
|
|
);
|
|
}
|
|
axisNormSquared += m_axis[component] * m_axis[component];
|
|
}
|
|
if (!std::isfinite(axisNormSquared) || axisNormSquared <= 0.0) {
|
|
throw std::invalid_argument("A fixed-angular-momentum rotation axis must be nonzero.");
|
|
}
|
|
const double inverseAxisNorm = 1.0 / std::sqrt(axisNormSquared);
|
|
for (double &component : m_axis) {
|
|
component *= inverseAxisNorm;
|
|
}
|
|
}
|
|
|
|
explicit FixedAngularMomentum(const TargetValue targetAngularMomentum)
|
|
: FixedAngularMomentum(Parameters{.Jtotal = targetAngularMomentum}) {
|
|
}
|
|
|
|
[[nodiscard]] TargetValue targetAngularMomentum() const noexcept {
|
|
return m_targetAngularMomentum;
|
|
}
|
|
|
|
[[nodiscard]] TargetValue target() const noexcept {
|
|
return m_targetAngularMomentum;
|
|
}
|
|
|
|
[[nodiscard]] const std::array<
|
|
double,
|
|
3> &
|
|
axis() const noexcept {
|
|
return m_axis;
|
|
}
|
|
|
|
[[nodiscard]] const std::array<
|
|
double,
|
|
3> &
|
|
center() const noexcept {
|
|
return m_center;
|
|
}
|
|
|
|
private:
|
|
TargetValue m_targetAngularMomentum;
|
|
std::array<double, 3> m_axis;
|
|
std::array<double, 3> m_center;
|
|
};
|
|
|
|
class FixedCentralDensity final {
|
|
public:
|
|
struct Parameters final {
|
|
dimensions::DensityValue RhoC;
|
|
};
|
|
|
|
using ScalarDescription = DimensionalScalarConstraint<
|
|
dimensions::quantity::Density,
|
|
dimensions::quantity::SpecificEnthalpy,
|
|
dimensions::quantity::SpecificEnthalpy,
|
|
"fixed_central_density.border",
|
|
"lambda_rho_c",
|
|
"fixed_central_density.residual",
|
|
"R_rho_c">;
|
|
using TargetValue = typename ScalarDescription::TargetValue;
|
|
using ModelDefinition = PhaseCondition<
|
|
FixedCentralDensity,
|
|
"FixedCentralDensity",
|
|
DependsOn<stellar::state::SpecificEnthalpy>,
|
|
Affects<stellar::equation::HydrostaticBalance>,
|
|
typename ScalarDescription::Normalization,
|
|
typename ScalarDescription::Manifest>;
|
|
|
|
explicit FixedCentralDensity(const Parameters parameters) : FixedCentralDensity(parameters.RhoC) {
|
|
}
|
|
|
|
explicit FixedCentralDensity(const TargetValue targetDensity) : m_targetDensity(targetDensity) {
|
|
if (!std::isfinite(targetDensity.value()) || targetDensity.value() <= 0.0) {
|
|
throw std::invalid_argument(
|
|
std::format(
|
|
"The fixed central density must be finite and positive. "
|
|
"Instead rho_c = {} was provided.",
|
|
targetDensity.value()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] TargetValue targetDensity() const noexcept {
|
|
return m_targetDensity;
|
|
}
|
|
|
|
[[nodiscard]] TargetValue target() const noexcept {
|
|
return m_targetDensity;
|
|
}
|
|
|
|
private:
|
|
TargetValue m_targetDensity;
|
|
};
|
|
|
|
template <typename Query, typename List> struct ModelTypeListContains;
|
|
|
|
template <typename Query, typename... Types>
|
|
struct ModelTypeListContains<Query, ModelTypeList<Types...>>
|
|
: std::bool_constant<(std::same_as<Query, Types> || ...)> { };
|
|
|
|
template <typename Query, typename List>
|
|
inline constexpr bool modelTypeListContains = ModelTypeListContains<Query, List>::value;
|
|
|
|
template <typename Specification> struct ResidualFor final {
|
|
using SpecificationType = Specification;
|
|
|
|
static constexpr std::size_t scalarArity = 1;
|
|
};
|
|
|
|
template <typename Specification> struct MultiplierFor final {
|
|
using SpecificationType = Specification;
|
|
|
|
static constexpr std::size_t scalarArity = 1;
|
|
};
|
|
|
|
// A generated state variable that participates directly in the physical
|
|
// equations, rather than serving only as a Lagrange multiplier or border.
|
|
template <typename Specification> struct PhysicalCoordinateFor final {
|
|
using SpecificationType = Specification;
|
|
|
|
static constexpr std::size_t scalarArity = 1;
|
|
};
|
|
|
|
template <typename Specification> struct BorderFor final {
|
|
using SpecificationType = Specification;
|
|
|
|
static constexpr std::size_t scalarArity = 1;
|
|
};
|
|
|
|
template <typename Candidate>
|
|
concept CoordinateNormalizationDefinition = requires {
|
|
{ Candidate::topology } -> std::convertible_to<RieszTopology>;
|
|
{ Candidate::scale } -> std::convertible_to<PhysicalScaleLaw>;
|
|
{ Candidate::available } -> std::convertible_to<bool>;
|
|
};
|
|
|
|
template <typename Candidate>
|
|
concept GeneratedNormalizationDefinition = requires {
|
|
typename Candidate::Value;
|
|
typename Candidate::Residual;
|
|
requires CoordinateNormalizationDefinition<typename Candidate::Value>;
|
|
requires CoordinateNormalizationDefinition<typename Candidate::Residual>;
|
|
{ Candidate::available } -> std::convertible_to<bool>;
|
|
};
|
|
|
|
template <typename Candidate>
|
|
concept GeneratedManifestDefinition = requires {
|
|
{ Candidate::valueStableId } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::valueSymbol } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::residualStableId } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::residualSymbol } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::targetUnits } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::residualUnits } -> std::convertible_to<std::string_view>;
|
|
{ Candidate::available } -> std::convertible_to<bool>;
|
|
};
|
|
|
|
namespace detail {
|
|
template <typename Specification, GeneratedStateKind Kind> struct GeneratedSignatureFor;
|
|
|
|
template <typename Specification> struct GeneratedSignatureFor<Specification, GeneratedStateKind::none> {
|
|
using Values = ModelTypeList<>;
|
|
using Residuals = ModelTypeList<>;
|
|
};
|
|
|
|
template <typename Specification> struct GeneratedSignatureFor<Specification, GeneratedStateKind::multiplier> {
|
|
using Values = ModelTypeList<MultiplierFor<Specification>>;
|
|
using Residuals = ModelTypeList<ResidualFor<Specification>>;
|
|
};
|
|
|
|
template <typename Specification>
|
|
struct GeneratedSignatureFor<Specification, GeneratedStateKind::physical_coordinate> {
|
|
using Values = ModelTypeList<PhysicalCoordinateFor<Specification>>;
|
|
using Residuals = ModelTypeList<ResidualFor<Specification>>;
|
|
};
|
|
|
|
template <typename Specification>
|
|
struct GeneratedSignatureFor<Specification, GeneratedStateKind::solver_border> {
|
|
using Values = ModelTypeList<BorderFor<Specification>>;
|
|
using Residuals = ModelTypeList<ResidualFor<Specification>>;
|
|
};
|
|
|
|
template <typename Candidate> struct SafeGeneratedNormalization {
|
|
using Type = UnavailableGeneratedNormalization;
|
|
};
|
|
|
|
template <GeneratedNormalizationDefinition Candidate> struct SafeGeneratedNormalization<Candidate> {
|
|
using Type = Candidate;
|
|
};
|
|
|
|
template <typename Candidate> struct SafeGeneratedManifest {
|
|
using Type = UnavailableGeneratedManifest;
|
|
};
|
|
|
|
template <GeneratedManifestDefinition Candidate> struct SafeGeneratedManifest<Candidate> {
|
|
using Type = Candidate;
|
|
};
|
|
} // namespace detail
|
|
|
|
template <ModelSpecification Specification> struct SpecificationContribution {
|
|
private:
|
|
using CanonicalSpecification = std::remove_cvref_t<Specification>;
|
|
using Definition = ModelDefinitionForT<CanonicalSpecification>;
|
|
using Signature = detail::GeneratedSignatureFor<CanonicalSpecification, Definition::generatedStateKind>;
|
|
|
|
public:
|
|
using SpecificationType = CanonicalSpecification;
|
|
using ModelDefinition = Definition;
|
|
using GeneratedValues = typename Signature::Values;
|
|
using GeneratedResiduals = typename Signature::Residuals;
|
|
using DependsOn = typename Definition::DependsOn;
|
|
using Affects = typename Definition::Affects;
|
|
using Normalization = typename detail::SafeGeneratedNormalization<typename Definition::Normalization>::Type;
|
|
using Manifest = typename detail::SafeGeneratedManifest<typename Definition::Manifest>::Type;
|
|
|
|
static constexpr GeneratedStateKind generatedStateKind = Definition::generatedStateKind;
|
|
static constexpr std::size_t generatedValueArity = Definition::generatedValueArity;
|
|
static constexpr std::size_t generatedResidualArity = Definition::generatedResidualArity;
|
|
static constexpr bool isDefined = Definition::structurallyAvailable;
|
|
static constexpr bool hasDeclarativeDefinition = Definition::structurallyAvailable;
|
|
};
|
|
|
|
namespace detail {
|
|
template <ModelSpecification Specification>
|
|
[[nodiscard]] consteval bool generatedScalarDimensionsAreCoherent() {
|
|
using Contribution = SpecificationContribution<Specification>;
|
|
using Normalization = typename Contribution::Normalization;
|
|
using Manifest = typename Contribution::Manifest;
|
|
|
|
if constexpr (Contribution::generatedValueArity == 0) {
|
|
return true;
|
|
} else {
|
|
constexpr bool normalizationIsTyped = requires {
|
|
typename Normalization::TargetQuantity;
|
|
typename Normalization::GeneratedCoordinateQuantity;
|
|
typename Normalization::ConstraintResidualQuantity;
|
|
typename Normalization::TargetValue;
|
|
{ Normalization::targetScale } -> std::convertible_to<PhysicalScaleLaw>;
|
|
};
|
|
constexpr bool manifestIsTyped = requires {
|
|
typename Manifest::TargetQuantity;
|
|
typename Manifest::GeneratedCoordinateQuantity;
|
|
typename Manifest::ConstraintResidualQuantity;
|
|
};
|
|
|
|
/* The lower-level declaration API remains a deliberate
|
|
* compatibility escape hatch. Once either half opts into the
|
|
* dimensional protocol, however, the complete typed contract
|
|
* is mandatory and cannot be mixed with free-form metadata. */
|
|
if constexpr (!normalizationIsTyped && !manifestIsTyped) {
|
|
return true;
|
|
} else if constexpr (!normalizationIsTyped || !manifestIsTyped) {
|
|
return false;
|
|
} else {
|
|
using TargetQuantity = typename Normalization::TargetQuantity;
|
|
using GeneratedCoordinateQuantity = typename Normalization::GeneratedCoordinateQuantity;
|
|
using ConstraintResidualQuantity = typename Normalization::ConstraintResidualQuantity;
|
|
using ValueNormalization = typename Normalization::Value;
|
|
using ResidualNormalization = typename Normalization::Residual;
|
|
|
|
if constexpr (
|
|
!PhysicalScaleRepresentedQuantity<TargetQuantity> ||
|
|
!PhysicalScaleRepresentedQuantity<GeneratedCoordinateQuantity> ||
|
|
!PhysicalScaleRepresentedQuantity<ConstraintResidualQuantity>
|
|
) {
|
|
return false;
|
|
} else if constexpr (
|
|
!requires {
|
|
typename std::integral_constant<
|
|
PhysicalScaleLaw, static_cast<PhysicalScaleLaw>(Normalization::targetScale)>;
|
|
typename std::integral_constant<
|
|
PhysicalScaleLaw, static_cast<PhysicalScaleLaw>(ValueNormalization::scale)>;
|
|
typename std::integral_constant<
|
|
PhysicalScaleLaw, static_cast<PhysicalScaleLaw>(ResidualNormalization::scale)>;
|
|
typename std::bool_constant<
|
|
static_cast<std::string_view>(Manifest::targetUnits) == TargetQuantity::identifier>;
|
|
typename std::bool_constant<
|
|
static_cast<std::string_view>(Manifest::residualUnits) ==
|
|
ConstraintResidualQuantity::identifier>;
|
|
}
|
|
) {
|
|
return false;
|
|
} else if constexpr (!requires(const Specification &specification) { specification.target(); }) {
|
|
return false;
|
|
} else {
|
|
return std::same_as<
|
|
typename Normalization::TargetValue, dimensions::QuantityValue<TargetQuantity>> &&
|
|
Normalization::targetScale == physicalScaleForQuantity<TargetQuantity> &&
|
|
std::same_as<TargetQuantity, typename Manifest::TargetQuantity> &&
|
|
std::same_as<
|
|
GeneratedCoordinateQuantity, typename Manifest::GeneratedCoordinateQuantity> &&
|
|
std::same_as<
|
|
ConstraintResidualQuantity, typename Manifest::ConstraintResidualQuantity> &&
|
|
ValueNormalization::scale == physicalScaleForQuantity<GeneratedCoordinateQuantity> &&
|
|
ResidualNormalization::scale == physicalScaleForQuantity<ConstraintResidualQuantity> &&
|
|
static_cast<std::string_view>(Manifest::targetUnits) == TargetQuantity::identifier &&
|
|
static_cast<std::string_view>(Manifest::residualUnits) ==
|
|
ConstraintResidualQuantity::identifier &&
|
|
std::same_as<
|
|
std::remove_cvref_t<decltype(std::declval<const Specification &>().target())>,
|
|
typename Normalization::TargetValue>;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // namespace detail
|
|
|
|
template <typename Specification>
|
|
concept CompleteGeneratedScalarDimensionsFor =
|
|
ModelSpecification<Specification> &&
|
|
detail::generatedScalarDimensionsAreCoherent<std::remove_cvref_t<Specification>>();
|
|
|
|
template <typename Specification>
|
|
concept CompleteGeneratedNormalizationFor =
|
|
ModelSpecification<Specification> && CompleteGeneratedScalarDimensionsFor<Specification> &&
|
|
(SpecificationContribution<std::remove_cvref_t<Specification>>::generatedValueArity == 0 ||
|
|
SpecificationContribution<std::remove_cvref_t<Specification>>::Normalization::available);
|
|
|
|
template <typename Specification>
|
|
concept CompleteGeneratedManifestFor =
|
|
ModelSpecification<Specification> && CompleteGeneratedScalarDimensionsFor<Specification> &&
|
|
(SpecificationContribution<std::remove_cvref_t<Specification>>::generatedValueArity == 0 ||
|
|
SpecificationContribution<std::remove_cvref_t<Specification>>::Manifest::available);
|
|
|
|
template <typename Candidate>
|
|
concept ResolvedModelSpecification =
|
|
ModelSpecification<Candidate> && SpecificationContribution<std::remove_cvref_t<Candidate>>::isDefined;
|
|
|
|
namespace detail {
|
|
template <typename... Specifications> struct SpecificationSetStorage final {
|
|
static constexpr std::size_t size = sizeof...(Specifications);
|
|
};
|
|
|
|
template <typename... Lists> struct ConcatenateModelTypeLists;
|
|
|
|
template <> struct ConcatenateModelTypeLists<> {
|
|
using Type = ModelTypeList<>;
|
|
};
|
|
|
|
template <typename... Types> struct ConcatenateModelTypeLists<ModelTypeList<Types...>> {
|
|
using Type = ModelTypeList<Types...>;
|
|
};
|
|
|
|
template <typename... First, typename... Second, typename... Remaining>
|
|
struct ConcatenateModelTypeLists<ModelTypeList<First...>, ModelTypeList<Second...>, Remaining...> {
|
|
using Type = typename ConcatenateModelTypeLists<ModelTypeList<First..., Second...>, Remaining...>::Type;
|
|
};
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet> struct SpecificationsForRole {
|
|
using Type = ModelTypeList<>;
|
|
|
|
static constexpr bool available = false;
|
|
static constexpr std::size_t count = 0;
|
|
};
|
|
|
|
template <SpecificationRole Role, ModelSpecification... Specifications>
|
|
struct SpecificationsForRole<Role, SpecificationSetStorage<Specifications...>> {
|
|
using Type = typename ConcatenateModelTypeLists<std::conditional_t<
|
|
SpecificationTraits<Specifications>::role == Role,
|
|
ModelTypeList<Specifications>,
|
|
ModelTypeList<>>...>::Type;
|
|
|
|
static constexpr bool available = true;
|
|
static constexpr std::size_t count = Type::size;
|
|
};
|
|
|
|
template <typename Types> struct UniqueModelType;
|
|
|
|
template <typename Type> struct UniqueModelType<ModelTypeList<Type>> {
|
|
using TypeValue = Type;
|
|
};
|
|
|
|
template <ModelSpecification Specification, typename Set> struct InsertSpecification;
|
|
|
|
template <ModelSpecification Specification>
|
|
struct InsertSpecification<Specification, SpecificationSetStorage<>> {
|
|
using Type = SpecificationSetStorage<Specification>;
|
|
};
|
|
|
|
template <ModelSpecification Specification, ModelSpecification Head, ModelSpecification... Tail>
|
|
struct InsertSpecification<Specification, SpecificationSetStorage<Head, Tail...>> {
|
|
private:
|
|
using InsertedTail = typename InsertSpecification<Specification, SpecificationSetStorage<Tail...>>::Type;
|
|
|
|
template <typename First, typename Rest> struct PrependSpecification;
|
|
|
|
template <typename First, ModelSpecification... Rest>
|
|
struct PrependSpecification<First, SpecificationSetStorage<Rest...>> {
|
|
using Type = SpecificationSetStorage<First, Rest...>;
|
|
};
|
|
|
|
public:
|
|
using Type = std::conditional_t<
|
|
(SpecificationTraits<Specification>::key < SpecificationTraits<Head>::key),
|
|
SpecificationSetStorage<Specification, Head, Tail...>,
|
|
typename PrependSpecification<Head, InsertedTail>::Type>;
|
|
};
|
|
|
|
template <typename Set, ModelSpecification... Specifications> struct CanonicalizeSpecifications;
|
|
|
|
template <typename Set> struct CanonicalizeSpecifications<Set> {
|
|
using Type = Set;
|
|
};
|
|
|
|
template <typename Set, ModelSpecification Head, ModelSpecification... Tail>
|
|
struct CanonicalizeSpecifications<Set, Head, Tail...> {
|
|
using Inserted = typename InsertSpecification<Head, Set>::Type;
|
|
using Type = typename CanonicalizeSpecifications<Inserted, Tail...>::Type;
|
|
};
|
|
|
|
template <ModelSpecification... Specifications>
|
|
using CanonicalSpecificationSet =
|
|
typename CanonicalizeSpecifications<SpecificationSetStorage<>, Specifications...>::Type;
|
|
|
|
template <
|
|
ModelSpecification Head,
|
|
ModelSpecification... Tail>
|
|
consteval bool specificationKeyIsUnique() {
|
|
constexpr auto headKey = SpecificationTraits<Head>::key;
|
|
return (
|
|
(headKey.role != SpecificationTraits<Tail>::key.role ||
|
|
headKey.stableName != SpecificationTraits<Tail>::key.stableName) &&
|
|
...
|
|
);
|
|
}
|
|
|
|
template <ModelSpecification... Specifications> struct SpecificationKeysAreUnique;
|
|
|
|
template <> struct SpecificationKeysAreUnique<> : std::true_type { };
|
|
|
|
template <ModelSpecification Head, ModelSpecification... Tail>
|
|
struct SpecificationKeysAreUnique<Head, Tail...>
|
|
: std::bool_constant<
|
|
specificationKeyIsUnique<Head, Tail...>() && SpecificationKeysAreUnique<Tail...>::value> { };
|
|
|
|
template <SpecificationRole Role, ModelSpecification... Specifications>
|
|
inline constexpr std::size_t specificationRoleCount =
|
|
(std::size_t{0} + ... + (SpecificationTraits<Specifications>::role == Role ? 1 : 0));
|
|
|
|
template <typename List> struct ModelTypeListScalarArity;
|
|
|
|
template <typename... Types>
|
|
struct ModelTypeListScalarArity<ModelTypeList<Types...>>
|
|
: std::integral_constant<std::size_t, (std::size_t{0} + ... + Types::scalarArity)> { };
|
|
|
|
template <typename Query, typename... Types>
|
|
inline constexpr bool isOneOf = (std::same_as<Query, Types> || ...);
|
|
|
|
template <typename Query, typename... Types>
|
|
inline constexpr std::size_t typeCount =
|
|
(std::size_t{0} + ... +
|
|
(std::same_as<Query, std::remove_cvref_t<Types>> ? std::size_t{1} : std::size_t{0}));
|
|
|
|
template <typename CanonicalSet, typename... Arguments> struct ArgumentsMatchCanonicalSpecifications;
|
|
|
|
template <ModelSpecification... CanonicalSpecifications, typename... Arguments>
|
|
struct ArgumentsMatchCanonicalSpecifications<SpecificationSetStorage<CanonicalSpecifications...>, Arguments...>
|
|
: std::bool_constant<
|
|
sizeof...(CanonicalSpecifications) == sizeof...(Arguments) &&
|
|
(isOneOf<std::remove_cvref_t<Arguments>, CanonicalSpecifications...> && ...) &&
|
|
((typeCount<CanonicalSpecifications, Arguments...> == 1) && ...)> { };
|
|
} // namespace detail
|
|
|
|
template <typename... Specifications>
|
|
requires(ModelSpecification<std::remove_cvref_t<Specifications>> && ...)
|
|
inline constexpr bool specificationKeysAreUnique =
|
|
detail::SpecificationKeysAreUnique<std::remove_cvref_t<Specifications>...>::value;
|
|
|
|
template <typename... Specifications>
|
|
concept ValidModelSpecificationPack =
|
|
(ResolvedModelSpecification<std::remove_cvref_t<Specifications>> && ...) &&
|
|
specificationKeysAreUnique<std::remove_cvref_t<Specifications>...> &&
|
|
detail::specificationRoleCount<SpecificationRole::constitutive_law, std::remove_cvref_t<Specifications>...> ==
|
|
1;
|
|
|
|
template <typename... Specifications>
|
|
requires(ModelSpecification<std::remove_cvref_t<Specifications>> && ...) &&
|
|
specificationKeysAreUnique<std::remove_cvref_t<Specifications>...>
|
|
using SpecificationSet = detail::CanonicalSpecificationSet<std::remove_cvref_t<Specifications>...>;
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet>
|
|
using SpecificationsForRoleT =
|
|
typename detail::SpecificationsForRole<Role, std::remove_cvref_t<SpecificationSet>>::Type;
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet>
|
|
inline constexpr std::size_t specificationRoleCount =
|
|
detail::SpecificationsForRole<Role, std::remove_cvref_t<SpecificationSet>>::count;
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet>
|
|
concept HasSpecificationsForRole =
|
|
detail::SpecificationsForRole<Role, std::remove_cvref_t<SpecificationSet>>::available &&
|
|
specificationRoleCount<Role, SpecificationSet> > 0;
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet>
|
|
concept HasUniqueSpecificationForRole =
|
|
detail::SpecificationsForRole<Role, std::remove_cvref_t<SpecificationSet>>::available &&
|
|
specificationRoleCount<Role, SpecificationSet> == 1;
|
|
|
|
template <SpecificationRole Role, typename SpecificationSet>
|
|
requires HasUniqueSpecificationForRole<Role, SpecificationSet>
|
|
using SpecificationForRoleT =
|
|
typename detail::UniqueModelType<SpecificationsForRoleT<Role, SpecificationSet>>::TypeValue;
|
|
|
|
template <typename SpecificationSet> struct SpecificationOperatorSignature;
|
|
|
|
template <ModelSpecification... Specifications>
|
|
struct SpecificationOperatorSignature<detail::SpecificationSetStorage<Specifications...>> final {
|
|
using GeneratedValues = typename detail::ConcatenateModelTypeLists<
|
|
typename SpecificationContribution<Specifications>::GeneratedValues...>::Type;
|
|
|
|
using GeneratedResiduals = typename detail::ConcatenateModelTypeLists<
|
|
typename SpecificationContribution<Specifications>::GeneratedResiduals...>::Type;
|
|
|
|
static constexpr std::size_t generatedValueArity = detail::ModelTypeListScalarArity<GeneratedValues>::value;
|
|
|
|
static constexpr std::size_t generatedResidualArity =
|
|
detail::ModelTypeListScalarArity<GeneratedResiduals>::value;
|
|
|
|
static constexpr bool symbolicallySquare = generatedValueArity == generatedResidualArity;
|
|
};
|
|
|
|
template <ResolvedModelSpecification Specification>
|
|
[[nodiscard]] consteval SpecificationDescriptor specificationDescriptor() {
|
|
using Contribution = SpecificationContribution<Specification>;
|
|
|
|
return {
|
|
.name = SpecificationTraits<Specification>::name,
|
|
.role = SpecificationTraits<Specification>::role,
|
|
.key = SpecificationTraits<Specification>::key,
|
|
.generatedValueArity = detail::ModelTypeListScalarArity<typename Contribution::GeneratedValues>::value,
|
|
.generatedResidualArity = detail::ModelTypeListScalarArity<typename Contribution::GeneratedResiduals>::value
|
|
};
|
|
}
|
|
|
|
namespace detail {
|
|
template <typename Specifications> class SpecifiedModel;
|
|
|
|
template <ModelSpecification... Specifications>
|
|
class SpecifiedModel<SpecificationSetStorage<Specifications...>> final {
|
|
private:
|
|
struct CanonicalArgumentsTag final { };
|
|
|
|
/*
|
|
* Capture the user-spelled pack once, then move each exact type
|
|
* into its canonical slot. Reconstructing an argument tuple in
|
|
* the pack expansion would forward every argument once per
|
|
* specification and silently consume move-sensitive physics
|
|
* objects multiple times.
|
|
*/
|
|
template <typename... ArgumentTypes>
|
|
explicit SpecifiedModel(
|
|
std::tuple<ArgumentTypes...> &&arguments,
|
|
CanonicalArgumentsTag
|
|
)
|
|
: m_specifications(std::get<Specifications>(std::move(arguments))...) {
|
|
}
|
|
|
|
public:
|
|
using SpecificationTypes = SpecificationSetStorage<Specifications...>;
|
|
using OperatorSignature = SpecificationOperatorSignature<SpecificationTypes>;
|
|
|
|
static constexpr bool symbolicallySquare = OperatorSignature::symbolicallySquare;
|
|
|
|
// A declaration can be complete before every physics name has a
|
|
// backend block mapping. Keep this deliberately separate from
|
|
// operators::StellarEquilibriumSystemCompilable<Model>.
|
|
static constexpr bool hasCompleteEquilibriumDeclaration =
|
|
symbolicallySquare && (SpecificationContribution<Specifications>::hasDeclarativeDefinition && ...);
|
|
|
|
template <typename... Arguments>
|
|
requires ArgumentsMatchCanonicalSpecifications<
|
|
SpecificationTypes,
|
|
Arguments...>::value &&
|
|
std::constructible_from<
|
|
std::tuple<std::remove_cvref_t<Arguments>...>,
|
|
Arguments...> &&
|
|
(std::constructible_from<
|
|
Specifications,
|
|
Specifications &&> &&
|
|
...)
|
|
explicit SpecifiedModel(Arguments &&...arguments)
|
|
: SpecifiedModel(
|
|
std::tuple<std::remove_cvref_t<Arguments>...>{std::forward<Arguments>(arguments)...},
|
|
CanonicalArgumentsTag{}
|
|
) {
|
|
}
|
|
|
|
template <ModelSpecification Specification>
|
|
requires isOneOf<
|
|
Specification,
|
|
Specifications...>
|
|
[[nodiscard]] const Specification &specification() const noexcept {
|
|
return std::get<Specification>(m_specifications);
|
|
}
|
|
|
|
template <ModelSpecification Specification>
|
|
static constexpr bool containsSpecification = isOneOf<Specification, Specifications...>;
|
|
|
|
[[nodiscard]] static constexpr std::span<const RuntimeSpecificationDescriptor>
|
|
runtimeSpecificationDescriptors() noexcept {
|
|
return runtimeDescriptors;
|
|
}
|
|
|
|
private:
|
|
inline static constexpr std::array<RuntimeSpecificationDescriptor, sizeof...(Specifications)>
|
|
runtimeDescriptors = [] {
|
|
std::array<RuntimeSpecificationDescriptor, sizeof...(Specifications)> descriptors{};
|
|
std::size_t index = 0;
|
|
((descriptors[index] =
|
|
{.specification = specificationDescriptor<Specifications>(),
|
|
.canonicalIndex = index,
|
|
.hasDeclarativeDefinition =
|
|
SpecificationContribution<Specifications>::hasDeclarativeDefinition},
|
|
++index),
|
|
...);
|
|
return descriptors;
|
|
}();
|
|
|
|
std::tuple<Specifications...> m_specifications;
|
|
};
|
|
} // namespace detail
|
|
|
|
template <ModelSpecification... Specifications>
|
|
requires ValidModelSpecificationPack<Specifications...> &&
|
|
SpecificationOperatorSignature<SpecificationSet<Specifications...>>::symbolicallySquare
|
|
using Model = detail::SpecifiedModel<SpecificationSet<Specifications...>>;
|
|
|
|
template <typename Candidate>
|
|
concept SpecifiedModelType = requires {
|
|
typename std::remove_cvref_t<Candidate>::SpecificationTypes;
|
|
typename std::remove_cvref_t<Candidate>::OperatorSignature;
|
|
requires std::remove_cvref_t<Candidate>::symbolicallySquare;
|
|
{ std::remove_cvref_t<Candidate>::hasCompleteEquilibriumDeclaration } -> std::convertible_to<bool>;
|
|
{
|
|
std::remove_cvref_t<Candidate>::runtimeSpecificationDescriptors()
|
|
} -> std::same_as<std::span<const RuntimeSpecificationDescriptor>>;
|
|
};
|
|
|
|
static_assert(ModelSpecification<eos::Polytrope>);
|
|
static_assert(ModelSpecification<surface::ConstantPressureSurface>);
|
|
static_assert(ModelSpecification<FixedTotalMass>);
|
|
static_assert(ModelSpecification<FixedAngularMomentum>);
|
|
static_assert(ModelSpecification<FixedCentralDensity>);
|
|
static_assert(ResolvedModelSpecification<eos::Polytrope>);
|
|
static_assert(ResolvedModelSpecification<surface::ConstantPressureSurface>);
|
|
static_assert(ResolvedModelSpecification<FixedTotalMass>);
|
|
static_assert(ResolvedModelSpecification<FixedAngularMomentum>);
|
|
static_assert(ResolvedModelSpecification<FixedCentralDensity>);
|
|
static_assert(CompleteGeneratedScalarDimensionsFor<FixedTotalMass>);
|
|
static_assert(CompleteGeneratedScalarDimensionsFor<FixedAngularMomentum>);
|
|
static_assert(CompleteGeneratedScalarDimensionsFor<FixedCentralDensity>);
|
|
} // namespace mean_field::models
|
|
|
|
/*
|
|
* Astronomer-facing declaration vocabulary. These aliases deliberately
|
|
* package the backend model lists, normalization topology, and manifest pair
|
|
* without duplicating any compiler logic. Advanced code may still use the
|
|
* models:: spellings directly; both paths produce exactly the same types.
|
|
*/
|
|
export namespace mean_field::stellar {
|
|
namespace state {
|
|
using Density = models::stellar::state::Density;
|
|
using SurfaceShape = models::stellar::state::SurfaceShape;
|
|
using GravityGradient = models::stellar::state::GravityGradient;
|
|
using GravitationalPotential = models::stellar::state::GravitationalPotential;
|
|
using SpecificEnthalpy = models::stellar::state::SpecificEnthalpy;
|
|
using OwnGeneratedCoordinate = models::stellar::state::OwnGeneratedCoordinate;
|
|
|
|
template <typename Specification>
|
|
using GeneratedCoordinateOf = models::stellar::state::GeneratedCoordinateOf<Specification>;
|
|
} // namespace state
|
|
|
|
namespace equation {
|
|
using GravityGradientDefinition = models::stellar::equation::GravityGradientDefinition;
|
|
using PoissonEquation = models::stellar::equation::PoissonEquation;
|
|
using DensityClosure = models::stellar::equation::DensityClosure;
|
|
using SurfaceShapeBalance = models::stellar::equation::SurfaceShapeBalance;
|
|
using HydrostaticBalance = models::stellar::equation::HydrostaticBalance;
|
|
using OwnConstraint = models::stellar::equation::OwnConstraint;
|
|
|
|
template <typename Specification> using ConstraintOf = models::stellar::equation::ConstraintOf<Specification>;
|
|
} // namespace equation
|
|
|
|
template <typename Equation, typename State> using Derivative = models::stellar::Derivative<Equation, State>;
|
|
|
|
template <typename... Quantities> using Reads = models::DependsOn<Quantities...>;
|
|
|
|
template <typename... Equations> using Changes = models::Affects<Equations...>;
|
|
|
|
using PhysicalScale = models::PhysicalScaleLaw;
|
|
|
|
template <
|
|
models::PhysicalScaleRepresentedQuantity TargetQuantity,
|
|
models::PhysicalScaleRepresentedQuantity GeneratedCoordinateQuantity,
|
|
models::PhysicalScaleRepresentedQuantity ConstraintResidualQuantity,
|
|
models::FixedString ValueStableId,
|
|
models::FixedString ValueSymbol,
|
|
models::FixedString ResidualStableId,
|
|
models::FixedString ResidualSymbol>
|
|
using ScalarConstraint = models::DimensionalScalarConstraint<
|
|
TargetQuantity,
|
|
GeneratedCoordinateQuantity,
|
|
ConstraintResidualQuantity,
|
|
ValueStableId,
|
|
ValueSymbol,
|
|
ResidualStableId,
|
|
ResidualSymbol>;
|
|
|
|
template <typename Candidate>
|
|
concept ScalarConstraintDescription = requires {
|
|
typename std::remove_cvref_t<Candidate>::Normalization;
|
|
typename std::remove_cvref_t<Candidate>::Manifest;
|
|
typename std::remove_cvref_t<Candidate>::TargetQuantity;
|
|
typename std::remove_cvref_t<Candidate>::GeneratedCoordinateQuantity;
|
|
typename std::remove_cvref_t<Candidate>::ConstraintResidualQuantity;
|
|
typename std::remove_cvref_t<Candidate>::TargetValue;
|
|
requires models::GeneratedNormalizationDefinition<typename std::remove_cvref_t<Candidate>::Normalization>;
|
|
requires models::GeneratedManifestDefinition<typename std::remove_cvref_t<Candidate>::Manifest>;
|
|
requires std::remove_cvref_t<Candidate>::Normalization::available;
|
|
requires std::remove_cvref_t<Candidate>::Manifest::available;
|
|
requires std::remove_cvref_t<Candidate>::dimensionallyTyped;
|
|
};
|
|
} // namespace mean_field::stellar
|
|
|
|
export namespace mean_field::integral {
|
|
using FixedTotalMass = models::FixedTotalMass;
|
|
using FixedAngularMomentum = models::FixedAngularMomentum;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename DependsOn = models::ModelTypeList<>,
|
|
typename Affects = models::ModelTypeList<>,
|
|
typename Normalization = models::UnavailableGeneratedNormalization,
|
|
typename Manifest = models::UnavailableGeneratedManifest>
|
|
using FixedIntegralWithMultiplier =
|
|
models::FixedIntegralWithMultiplier<Specification, Name, DependsOn, Affects, Normalization, Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename DependsOn = models::ModelTypeList<>,
|
|
typename Affects = models::ModelTypeList<>,
|
|
typename Normalization = models::UnavailableGeneratedNormalization,
|
|
typename Manifest = models::UnavailableGeneratedManifest>
|
|
using FixedWithMultiplier =
|
|
FixedIntegralWithMultiplier<Specification, Name, DependsOn, Affects, Normalization, Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename DependsOn = models::ModelTypeList<>,
|
|
typename Affects = models::ModelTypeList<>,
|
|
typename Normalization = models::UnavailableGeneratedNormalization,
|
|
typename Manifest = models::UnavailableGeneratedManifest>
|
|
using FixedIntegralWithPhysicalCoordinate =
|
|
models::FixedIntegralWithPhysicalCoordinate<Specification, Name, DependsOn, Affects, Normalization, Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename DependsOn = models::ModelTypeList<>,
|
|
typename Affects = models::ModelTypeList<>,
|
|
typename Normalization = models::UnavailableGeneratedNormalization,
|
|
typename Manifest = models::UnavailableGeneratedManifest>
|
|
using FixedWithPhysicalCoordinate =
|
|
FixedIntegralWithPhysicalCoordinate<Specification, Name, DependsOn, Affects, Normalization, Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename Reads,
|
|
typename Changes,
|
|
stellar::ScalarConstraintDescription Description>
|
|
using FixedScalarWithMultiplier = models::FixedIntegralWithMultiplier<
|
|
Specification,
|
|
Name,
|
|
Reads,
|
|
Changes,
|
|
typename Description::Normalization,
|
|
typename Description::Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename Reads,
|
|
typename Changes,
|
|
stellar::ScalarConstraintDescription Description>
|
|
using FixedScalarWithPhysicalCoordinate = models::FixedIntegralWithPhysicalCoordinate<
|
|
Specification,
|
|
Name,
|
|
Reads,
|
|
Changes,
|
|
typename Description::Normalization,
|
|
typename Description::Manifest>;
|
|
} // namespace mean_field::integral
|
|
|
|
export namespace mean_field::constraint {
|
|
using FixedCentralDensity = models::FixedCentralDensity;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename DependsOn = models::ModelTypeList<>,
|
|
typename Affects = models::ModelTypeList<>,
|
|
typename Normalization = models::UnavailableGeneratedNormalization,
|
|
typename Manifest = models::UnavailableGeneratedManifest>
|
|
using PhaseCondition = models::PhaseCondition<Specification, Name, DependsOn, Affects, Normalization, Manifest>;
|
|
|
|
template <
|
|
typename Specification,
|
|
models::FixedString Name,
|
|
typename Reads,
|
|
typename Changes,
|
|
stellar::ScalarConstraintDescription Description>
|
|
using ScalarPhaseCondition = models::PhaseCondition<
|
|
Specification,
|
|
Name,
|
|
Reads,
|
|
Changes,
|
|
typename Description::Normalization,
|
|
typename Description::Manifest>;
|
|
} // namespace mean_field::constraint
|
|
|
|
export namespace mean_field::eos {
|
|
template <typename Specification, models::FixedString Name>
|
|
using ConstitutiveLaw = models::ConstitutiveLaw<Specification, Name>;
|
|
}
|
|
|
|
export namespace mean_field::surface {
|
|
template <typename Specification, models::FixedString Name>
|
|
using BoundaryCondition = models::BoundaryCondition<Specification, Name>;
|
|
}
|