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

feat(field-support): added field support system, mid migration

Browse Source 
currently the barotope and the pressure force operator are migrated to the new support system
This commit is contained in:
Emily Boudreaux
2026-08-23 10:13:53 -04:00
parent dc912fd15e
commit 0f3ca8050b
137 changed files with 29975 additions and 16389 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
libmeanfield/interface/operators/contexts/barotropic_closure_linearization_context.cppm
View File

@@ -1,5 +1,6 @@
module;
#include <compare>
#include <cstdint>
#include <mfem.hpp>
@@ -7,18 +8,66 @@ module;
export module mean_field:operators.context.barotropic_closure_linearization;
export import :fem;
export import :field.mfem;
export import :mapping.domain_mapper;
export import :operators.prepared_barotropic_closure;
export import :physics.barotrope;
export namespace mean_field::operators::context::barotropic {
struct BarotropicClosureRevisions final {
std::uint64_t density = 0;
std::uint64_t enthalpy = 0;
std::uint64_t displacement = 0;
template <typename Tag> struct DependencyStamp {
std::uint64_t identity{0};
std::uint64_t revision{0};
[[nodiscard]] bool
operator==(const BarotropicClosureRevisions &) const noexcept = default;
[[nodiscard]] constexpr bool CanFollow(const DependencyStamp &prepared) const noexcept {
return identity != prepared.identity || revision >= prepared.revision;
}
constexpr auto operator<=>(const DependencyStamp &) const = default;
};
struct DiscretizationDependencyTag { };
struct DensityDependencyTag { };
struct EnthalpyDependencyTag { };
struct DisplacementDependencyTag { };
using DiscretizationDependency = DependencyStamp<DiscretizationDependencyTag>;
using DensityDependency = DependencyStamp<DensityDependencyTag>;
using EnthalpyDependency = DependencyStamp<EnthalpyDependencyTag>;
using DisplacementDependency = DependencyStamp<DisplacementDependencyTag>;
struct BarotropicClosureDependencies final {
DiscretizationDependency discretization;
DensityDependency density;
EnthalpyDependency enthalpy;
DisplacementDependency displacement;
constexpr auto operator<=>(const BarotropicClosureDependencies &) const = default;
};
struct BarotropicClosureStateView final {
const mfem::Vector &density;
const mfem::Vector &enthalpy;
const mfem::Vector &displacement;
};
struct BarotropicClosurePreparationReport final {
bool preparedStaticDependencies{false};
bool preparedGeometryState{false};
bool preparedBaseState{false};
bool updatedDensity{false};
bool updatedEnthalpy{false};
bool updatedDisplacement{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return preparedStaticDependencies || preparedGeometryState || preparedBaseState;
}
};
struct BarotropicClosurePreparationStatistics final {
std::uint64_t staticPreparations{0};
std::uint64_t geometryPreparations{0};
std::uint64_t baseStatePreparations{0};
constexpr auto operator<=>(const BarotropicClosurePreparationStatistics &) const = default;
};
class BarotropicClosureLinearizationContext final {
@@ -26,51 +75,46 @@ export namespace mean_field::operators::context::barotropic {
BarotropicClosureLinearizationContext(
const fem::FEM &f,
const mapping::DomainMapperStateless &domainMapper,
const physics::PolytropicBarotrope &barotrope
const field::FieldDofMap &densityMap,
const field::FieldDofMap &enthalpyMap,
const field::FieldDofMap &displacementMap
);
void Prepare(
const mfem::Vector &baseDensityTrue,
const mfem::Vector &baseEnthalpyTrue,
const mfem::Vector &displacementTrue,
const BarotropicClosureRevisions &revisions
BarotropicClosureLinearizationContext(const BarotropicClosureLinearizationContext &) = delete;
BarotropicClosureLinearizationContext &operator=(const BarotropicClosureLinearizationContext &) = delete;
BarotropicClosureLinearizationContext(BarotropicClosureLinearizationContext &&) = delete;
BarotropicClosureLinearizationContext &operator=(BarotropicClosureLinearizationContext &&) = delete;
BarotropicClosurePreparationReport Prepare(
const BarotropicClosureStateView &state,
const BarotropicClosureDependencies &dependencies
);
[[nodiscard]] bool IsPrepared() const noexcept;
[[nodiscard]] bool MatchesDependencies(const BarotropicClosureDependencies &dependencies) const noexcept;
[[nodiscard]] const BarotropicClosureDependencies &GetDependencies() const;
[[nodiscard]] const BarotropicClosurePreparationStatistics &GetPreparationStatistics() const noexcept;
[[nodiscard]] bool MatchesRevisions(
const BarotropicClosureRevisions &revisions
) const noexcept;
[[nodiscard]] std::uint64_t GetPreparationCount() const noexcept;
[[nodiscard]] const BarotropicClosureRevisions &GetRevisions() const;
[[nodiscard]] const mfem::Vector &GetBaseDensityTrue() const;
[[nodiscard]] const mfem::Vector &GetBaseEnthalpyTrue() const;
[[nodiscard]] const mfem::Vector &GetDisplacementTrue() const;
[[nodiscard]]
const PreparedBarotropicClosureOperator &GetOperator() const noexcept;
void BuildResidual(mfem::Vector &residual) const;
[[nodiscard]] const mfem::Vector &GetBaseDensity() const;
[[nodiscard]] const mfem::Vector &GetBaseEnthalpy() const;
[[nodiscard]] const mfem::Vector &GetDisplacement() const;
private:
void VerifyPrepared() const;
const fem::FEM &m_f;
const mapping::DomainMapperStateless &m_domainMapper;
PreparedBarotropicClosureOperator m_operator;
int m_densitySize{0};
int m_enthalpySize{0};
int m_displacementSize{0};
mfem::Vector m_baseDensityTrue;
mfem::Vector m_baseEnthalpyTrue;
mfem::Vector m_displacementTrue;
mfem::Vector m_baseDensity;
mfem::Vector m_baseEnthalpy;
mfem::Vector m_displacement;
BarotropicClosureRevisions m_revisions;
std::uint64_t m_preparationCount = 0;
bool m_isPrepared = false;
BarotropicClosureDependencies m_dependencies;
BarotropicClosurePreparationStatistics m_statistics;
bool m_isPrepared{false};
};
} // namespace mean_field::operators::context::barotropic
} // namespace mean_field::operators::context::barotropic

46
libmeanfield/interface/operators/contexts/gravity_field_context.cppm
View File

@@ -51,8 +51,8 @@ export namespace mean_field::operators::context::gravity_field {
bool refreshed_variation_state{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return reconstructed_operators || rebuilt_mass_operator ||
rebuilt_source_operator || refreshed_variation_state;
return reconstructed_operators || rebuilt_mass_operator || rebuilt_source_operator ||
refreshed_variation_state;
}
};
@@ -63,13 +63,10 @@ export namespace mean_field::operators::context::gravity_field {
const mapping::DomainMapperStateless &domain_mapper
);
GravityFieldGeometryContext(const GravityFieldGeometryContext &) =
delete;
GravityFieldGeometryContext &
operator=(const GravityFieldGeometryContext &) = delete;
GravityFieldGeometryContext(GravityFieldGeometryContext &&) = delete;
GravityFieldGeometryContext &
operator=(GravityFieldGeometryContext &&) = delete;
GravityFieldGeometryContext(const GravityFieldGeometryContext &) = delete;
GravityFieldGeometryContext &operator=(const GravityFieldGeometryContext &) = delete;
GravityFieldGeometryContext(GravityFieldGeometryContext &&) = delete;
GravityFieldGeometryContext &operator=(GravityFieldGeometryContext &&) = delete;
GravityFieldGeometryPreparation Prepare(
const mfem::Vector &displacement_true,
@@ -77,15 +74,11 @@ export namespace mean_field::operators::context::gravity_field {
DisplacementRevision displacement_revision
);
[[nodiscard]] const PreparedMappedHDivMassOperator &
GetMassOperator() const;
[[nodiscard]] const PreparedMappedGravitySourceOperator &
GetSourceOperator() const;
[[nodiscard]] const PreparedMappedHDivMassOperator &GetMassOperator() const;
[[nodiscard]] const PreparedMappedGravitySourceOperator &GetSourceOperator() const;
[[nodiscard]] const mfem::Vector &GetDisplacement() const;
[[nodiscard]] DiscretizationRevision
GetDiscretizationRevision() const noexcept;
[[nodiscard]] DisplacementRevision
GetDisplacementRevision() const noexcept;
[[nodiscard]] DiscretizationRevision GetDiscretizationRevision() const noexcept;
[[nodiscard]] DisplacementRevision GetDisplacementRevision() const noexcept;
[[nodiscard]] bool IsPrepared() const noexcept;
private:
@@ -109,8 +102,7 @@ export namespace mean_field::operators::context::gravity_field {
bool updated_gravity_gradient{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return geometry.DidAnyWork() || updated_density ||
updated_gravity_gradient;
return geometry.DidAnyWork() || updated_density || updated_gravity_gradient;
}
};
@@ -121,23 +113,17 @@ export namespace mean_field::operators::context::gravity_field {
const mapping::DomainMapperStateless &domain_mapper
);
GravityFieldLinearizationContext(
const GravityFieldLinearizationContext &
) = delete;
GravityFieldLinearizationContext &
operator=(const GravityFieldLinearizationContext &) = delete;
GravityFieldLinearizationContext(GravityFieldLinearizationContext &&) =
delete;
GravityFieldLinearizationContext &
operator=(GravityFieldLinearizationContext &&) = delete;
GravityFieldLinearizationContext(const GravityFieldLinearizationContext &) = delete;
GravityFieldLinearizationContext &operator=(const GravityFieldLinearizationContext &) = delete;
GravityFieldLinearizationContext(GravityFieldLinearizationContext &&) = delete;
GravityFieldLinearizationContext &operator=(GravityFieldLinearizationContext &&) = delete;
GravityFieldPreparationReport Prepare(
const GravityFieldStateView &state,
const GravityFieldRevisions &revisions
);
[[nodiscard]] const GravityFieldGeometryContext &
GetGeometryContext() const;
[[nodiscard]] const GravityFieldGeometryContext &GetGeometryContext() const;
[[nodiscard]] const mfem::Vector &GetDensity() const;
[[nodiscard]] const mfem::Vector &GetGravityGradient() const;
[[nodiscard]] const GravityFieldRevisions &GetRevisions() const;

53
libmeanfield/interface/operators/contexts/hydrostatic_equilibrium_context.cppm
View File

@@ -15,10 +15,8 @@ export namespace mean_field::operators::context::hydrostatic {
std::uint64_t identity{0};
std::uint64_t revision{0};
[[nodiscard]] constexpr bool
CanFollow(const DependencyStamp &prepared) const noexcept {
return identity != prepared.identity ||
revision >= prepared.revision;
[[nodiscard]] constexpr bool CanFollow(const DependencyStamp &prepared) const noexcept {
return identity != prepared.identity || revision >= prepared.revision;
}
constexpr auto operator<=>(const DependencyStamp &) const = default;
@@ -31,20 +29,17 @@ export namespace mean_field::operators::context::hydrostatic {
struct RotationDependencyTag { };
struct BernoulliConstantDependencyTag { };
using DiscretizationDependency =
DependencyStamp<DiscretizationDependencyTag>;
using DiscretizationDependency = DependencyStamp<DiscretizationDependencyTag>;
using EnthalpyDependency = DependencyStamp<EnthalpyDependencyTag>;
using EnthalpyDependency = DependencyStamp<EnthalpyDependencyTag>;
using GravityPotentialDependency =
DependencyStamp<GravityPotentialDependencyTag>;
using GravityPotentialDependency = DependencyStamp<GravityPotentialDependencyTag>;
using DisplacementDependency = DependencyStamp<DisplacementDependencyTag>;
using DisplacementDependency = DependencyStamp<DisplacementDependencyTag>;
using RotationDependency = DependencyStamp<RotationDependencyTag>;
using RotationDependency = DependencyStamp<RotationDependencyTag>;
using BernoulliConstantDependency =
DependencyStamp<BernoulliConstantDependencyTag>;
using BernoulliConstantDependency = DependencyStamp<BernoulliConstantDependencyTag>;
struct HydrostaticEquilibriumDependencies {
DiscretizationDependency discretization;
@@ -54,8 +49,7 @@ export namespace mean_field::operators::context::hydrostatic {
RotationDependency rotation;
BernoulliConstantDependency bernoulliConstant;
constexpr auto
operator<=>(const HydrostaticEquilibriumDependencies &) const = default;
constexpr auto operator<=>(const HydrostaticEquilibriumDependencies &) const = default;
};
struct HydrostaticEquilibriumStateView {
@@ -77,8 +71,8 @@ export namespace mean_field::operators::context::hydrostatic {
bool updatedBernoulliConstant{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return preparedStaticDependencies || preparedGeometryState ||
preparedRotationDependencies || preparedBaseState;
return preparedStaticDependencies || preparedGeometryState || preparedRotationDependencies ||
preparedBaseState;
}
};
@@ -88,8 +82,7 @@ export namespace mean_field::operators::context::hydrostatic {
std::uint64_t rotationPreparations{0};
std::uint64_t baseStatePreparations{0};
constexpr auto
operator<=>(const HydrostaticPreparationStatistics &) const = default;
constexpr auto operator<=>(const HydrostaticPreparationStatistics &) const = default;
};
class HydrostaticEquilibriumContext {
@@ -99,17 +92,13 @@ export namespace mean_field::operators::context::hydrostatic {
const mapping::DomainMapperStateless &domainMapper
);
HydrostaticEquilibriumContext(const HydrostaticEquilibriumContext &) =
delete;
HydrostaticEquilibriumContext(const HydrostaticEquilibriumContext &) = delete;
HydrostaticEquilibriumContext &
operator=(const HydrostaticEquilibriumContext &) = delete;
HydrostaticEquilibriumContext &operator=(const HydrostaticEquilibriumContext &) = delete;
HydrostaticEquilibriumContext(HydrostaticEquilibriumContext &&) =
delete;
HydrostaticEquilibriumContext(HydrostaticEquilibriumContext &&) = delete;
HydrostaticEquilibriumContext &
operator=(HydrostaticEquilibriumContext &&) = delete;
HydrostaticEquilibriumContext &operator=(HydrostaticEquilibriumContext &&) = delete;
HydrostaticPreparationReport Prepare(
const HydrostaticEquilibriumStateView &state,
@@ -118,15 +107,11 @@ export namespace mean_field::operators::context::hydrostatic {
[[nodiscard]] bool IsPrepared() const noexcept;
[[nodiscard]] bool MatchesDependencies(
const HydrostaticEquilibriumDependencies &dependencies
) const noexcept;
[[nodiscard]] bool MatchesDependencies(const HydrostaticEquilibriumDependencies &dependencies) const noexcept;
[[nodiscard]] const HydrostaticEquilibriumDependencies &
GetDependencies() const;
[[nodiscard]] const HydrostaticEquilibriumDependencies &GetDependencies() const;
[[nodiscard]] const HydrostaticPreparationStatistics &
GetPreparationStatistics() const noexcept;
[[nodiscard]] const HydrostaticPreparationStatistics &GetPreparationStatistics() const noexcept;
[[nodiscard]] const mfem::Vector &GetBaseEnthalpyTrue() const;

128
libmeanfield/interface/operators/contexts/pressure_force_context.cppm Normal file
View File

@@ -0,0 +1,128 @@
module;
#include <compare>
#include <cstdint>
#include <mfem.hpp>
export module mean_field:operators.context.pressure_force;
export import :fem;
export import :field.mfem;
export import :mapping.domain_mapper;
export namespace mean_field::operators::context::pressure_force {
template <typename Tag> struct DependencyStamp final {
std::uint64_t identity{0};
std::uint64_t revision{0};
[[nodiscard]] constexpr bool CanFollow(const DependencyStamp &prepared) const noexcept {
return identity != prepared.identity || revision >= prepared.revision;
}
constexpr auto operator<=>(const DependencyStamp &) const = default;
};
struct DiscretizationDependencyTag final { };
struct EnthalpyDependencyTag final { };
struct DisplacementDependencyTag final { };
using DiscretizationDependency = DependencyStamp<DiscretizationDependencyTag>;
using EnthalpyDependency = DependencyStamp<EnthalpyDependencyTag>;
using DisplacementDependency = DependencyStamp<DisplacementDependencyTag>;
struct PressureForceDependencies final {
DiscretizationDependency discretization;
EnthalpyDependency enthalpy;
DisplacementDependency displacement;
constexpr auto operator<=>(const PressureForceDependencies &) const = default;
};
/*
* Frozen solver-facing state.
*
* Both vectors use their registered FieldDof coordinates.
*
* Under the current registry:
*
* enthalpy -> Stellar -> reduced
* displacement -> All -> identity/full
*/
struct PressureForceStateView final {
const mfem::Vector &enthalpy;
const mfem::Vector &displacement;
};
struct PressureForcePreparationReport final {
bool preparedStaticDependencies{false};
bool preparedGeometryState{false};
bool preparedMaterialState{false};
bool updatedEnthalpy{false};
bool updatedDisplacement{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return preparedStaticDependencies || preparedGeometryState || preparedMaterialState;
}
};
struct PressureForcePreparationStatistics final {
std::uint64_t staticPreparations{0};
std::uint64_t geometryPreparations{0};
std::uint64_t materialPreparations{0};
constexpr auto operator<=>(const PressureForcePreparationStatistics &) const = default;
};
class PressureForceLinearizationContext final {
public:
PressureForceLinearizationContext(
const fem::FEM &f,
const mapping::DomainMapperStateless &domainMapper,
const field::FieldDofMap &enthalpyMap,
const field::FieldDofMap &displacementMap
);
PressureForceLinearizationContext(const PressureForceLinearizationContext &) = delete;
PressureForceLinearizationContext &operator=(const PressureForceLinearizationContext &) = delete;
PressureForceLinearizationContext(PressureForceLinearizationContext &&) = delete;
PressureForceLinearizationContext &operator=(PressureForceLinearizationContext &&) = delete;
PressureForcePreparationReport Prepare(
const PressureForceStateView &state,
const PressureForceDependencies &dependencies
);
[[nodiscard]] bool IsPrepared() const noexcept;
[[nodiscard]] bool MatchesDependencies(const PressureForceDependencies &dependencies) const noexcept;
[[nodiscard]] const PressureForceDependencies &GetDependencies() const;
[[nodiscard]] const PressureForcePreparationStatistics &GetPreparationStatistics() const noexcept;
[[nodiscard]] const mfem::Vector &GetBaseEnthalpy() const;
[[nodiscard]] const mfem::Vector &GetDisplacement() const;
private:
void VerifyPrepared() const;
int m_enthalpySize{0};
int m_displacementSize{0};
mfem::Vector m_baseEnthalpy;
mfem::Vector m_displacement;
PressureForcePreparationStatistics m_statistics;
PressureForceDependencies m_dependencies;
bool m_isPrepared{false};
};
} // namespace mean_field::operators::context::pressure_force

124
libmeanfield/interface/operators/contexts/rotation_displacement_force_context.cppm Normal file
View File

@@ -0,0 +1,124 @@
module;
#include <compare>
#include <cstdint>
#include <mfem.hpp>
export module mean_field:operators.context.rotational_displacement_force;
export import :fem;
export import :mapping.domain_mapper;
export namespace mean_field::operators::context::rotational_displacement_force {
template <typename Tag> struct DependencyStamp final {
std::uint64_t identity{0};
std::uint64_t revision{0};
[[nodiscard]] constexpr bool CanFollow(const DependencyStamp &prepared) const noexcept {
return identity != prepared.identity || revision >= prepared.revision;
}
constexpr auto operator<=>(const DependencyStamp &) const = default;
};
struct DiscretizationDependencyTag final { };
struct DensityDependencyTag final { };
struct DisplacementDependencyTag final { };
struct RotationDependencyTag final { };
using DiscretizationDependency = DependencyStamp<DiscretizationDependencyTag>;
using DensityDependency = DependencyStamp<DensityDependencyTag>;
using DisplacementDependency = DependencyStamp<DisplacementDependencyTag>;
using RotationDependency = DependencyStamp<RotationDependencyTag>;
struct RotationalDisplacementForceDependencies final {
DiscretizationDependency discretization;
DensityDependency density;
DisplacementDependency displacement;
RotationDependency rotation;
constexpr auto operator<=>(const RotationalDisplacementForceDependencies &) const = default;
};
struct RotationalDisplacementForceStateView final {
const mfem::Vector &density;
const mfem::Vector &displacement;
};
struct RotationalDisplacementForcePreparationReport final {
bool preparedStaticDependencies{false};
bool preparedGeometryState{false};
bool preparedRotationDependencies{false};
bool preparedBaseState{false};
bool updatedDensity{false};
bool updatedDisplacement{false};
[[nodiscard]] bool DidAnyWork() const noexcept {
return preparedStaticDependencies || preparedGeometryState || preparedRotationDependencies ||
preparedBaseState;
}
};
struct RotationalDisplacementForcePreparationStatistics final {
std::uint64_t staticPreparations{0};
std::uint64_t geometryPreparations{0};
std::uint64_t rotationPreparations{0};
std::uint64_t baseStatePreparations{0};
constexpr auto operator<=>(const RotationalDisplacementForcePreparationStatistics &) const = default;
};
class RotationalDisplacementForceLinearizationContext final {
public:
RotationalDisplacementForceLinearizationContext(
const fem::FEM &f,
const mapping::DomainMapperStateless &domainMapper
);
RotationalDisplacementForceLinearizationContext(const RotationalDisplacementForceLinearizationContext &) =
delete;
RotationalDisplacementForceLinearizationContext &
operator=(const RotationalDisplacementForceLinearizationContext &) = delete;
RotationalDisplacementForceLinearizationContext(RotationalDisplacementForceLinearizationContext &&) = delete;
RotationalDisplacementForceLinearizationContext &
operator=(RotationalDisplacementForceLinearizationContext &&) = delete;
RotationalDisplacementForcePreparationReport Prepare(
const RotationalDisplacementForceStateView &state,
const RotationalDisplacementForceDependencies &dependencies
);
[[nodiscard]] bool IsPrepared() const noexcept;
[[nodiscard]] bool
MatchesDependencies(const RotationalDisplacementForceDependencies &dependencies) const noexcept;
[[nodiscard]] const RotationalDisplacementForceDependencies &GetDependencies() const;
[[nodiscard]] const RotationalDisplacementForcePreparationStatistics &GetPreparationStatistics() const noexcept;
[[nodiscard]] const mfem::Vector &GetBaseDensityTrue() const;
[[nodiscard]] const mfem::Vector &GetDisplacementTrue() const;
private:
void VerifyPrepared() const;
const fem::FEM &m_f;
mfem::Vector m_baseDensityTrue;
mfem::Vector m_displacementTrue;
RotationalDisplacementForceDependencies m_dependencies;
RotationalDisplacementForcePreparationStatistics m_statistics;
bool m_isPrepared{false};
};
} // namespace mean_field::operators::context::rotational_displacement_force