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

feat(libmeanfield): variadic refactor

Browse Source 
also added normaliztion operator
This commit is contained in:
Emily Boudreaux
2026-09-06 10:15:00 -04:00
parent 71423d543f
commit 76818f2f82
63 changed files with 28794 additions and 1119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
libmeanfield/interface/models/compiled_fixed_angular_momentum.cppm Normal file
View File

@@ -0,0 +1,74 @@
module;
#include <concepts>
#include <cstddef>
#include <type_traits>
#include <mfem.hpp>
export module mean_field:model.compiled_fixed_angular_momentum;
export import :field.registry;
export import :model.compiled_fixed_mass;
export import :physics.rigid_rotation;
export import :utils.blocks;
export namespace mean_field::models {
using FixedAngularMomentumLayoutRequest = ConstraintLayoutRequest<
FixedAngularMomentum,
PhysicalCoordinateFor<FixedAngularMomentum>,
ResidualFor<FixedAngularMomentum>,
utils::blocks::fixed_angular_momentum::angular_velocity::value,
utils::blocks::fixed_angular_momentum::angular_velocity::residual,
utils::blocks::fixed_angular_momentum::angular_velocity,
utils::blocks::density::mass::value,
utils::blocks::surface_deformation::parameters::value,
utils::blocks::fixed_angular_momentum::angular_velocity::value>;
class CompiledFixedAngularMomentum final {
public:
using SpecificationType = FixedAngularMomentum;
using LayoutRequest = FixedAngularMomentumLayoutRequest;
using AngularVelocityType = typename LayoutRequest::GeneratedValueType;
using ResidualType = typename LayoutRequest::GeneratedResidualType;
using AngularVelocityField = field::AngularVelocity;
explicit CompiledFixedAngularMomentum(const FixedAngularMomentum specification) noexcept
: m_specification(specification) {
}
[[nodiscard]] const FixedAngularMomentum &specification() const noexcept {
return m_specification;
}
[[nodiscard]] dimensions::AngularMomentumValue targetAngularMomentum() const noexcept {
return m_specification.targetAngularMomentum();
}
[[nodiscard]] physics::RigidRotation makeRotation(const double angularVelocity) const {
mfem::Vector velocity(3);
mfem::Vector center(3);
for (int component = 0; component < 3; ++component) {
velocity(component) = angularVelocity * m_specification.axis()[static_cast<std::size_t>(component)];
center(component) = m_specification.center()[static_cast<std::size_t>(component)];
}
return {velocity, center};
}
[[nodiscard]] static consteval LayoutRequest layoutRequest() noexcept {
return {};
}
private:
FixedAngularMomentum m_specification;
};
[[nodiscard]] inline CompiledFixedAngularMomentum compileConstraint(
const FixedAngularMomentum specification
) noexcept {
return CompiledFixedAngularMomentum{specification};
}
static_assert(ConstraintLayoutRequestType<FixedAngularMomentumLayoutRequest>);
static_assert(CompiledConstraint<CompiledFixedAngularMomentum>);
} // namespace mean_field::models

1302
libmeanfield/interface/models/specifications.cppm
View File

File diff suppressed because it is too large Load Diff

115
libmeanfield/interface/models/typed_stellar_model.cppm
View File

@@ -14,21 +14,41 @@ export namespace mean_field::model {
template <typename SpecificationSet> class StellarModel;
template <models::ModelSpecification... CanonicalSpecifications>
requires models::ValidModelSpecificationPack<CanonicalSpecifications...> &&
models::SpecificationOperatorSignature<
models::detail::SpecificationSetStorage<CanonicalSpecifications...>>::symbolicallySquare
class StellarModel<models::detail::SpecificationSetStorage<CanonicalSpecifications...>> final {
public:
using SpecificationTypes = models::detail::SpecificationSetStorage<CanonicalSpecifications...>;
using OperatorSignature = models::SpecificationOperatorSignature<SpecificationTypes>;
using Storage = models::Model<CanonicalSpecifications...>;
using EquationOfStateType =
models::SpecificationForRoleT<models::SpecificationRole::constitutive_law, SpecificationTypes>;
static constexpr std::size_t specificationCount = sizeof...(CanonicalSpecifications);
static constexpr bool symbolicallySquare = Storage::symbolicallySquare;
static constexpr bool hasCompleteEquilibriumCompiler = Storage::hasCompleteRootCompiler;
static constexpr models::EquilibriumSystemCompilation compilationClass = Storage::compilationClass;
static constexpr std::size_t specificationCount = sizeof...(CanonicalSpecifications);
static constexpr bool symbolicallySquare = Storage::symbolicallySquare;
static constexpr bool hasCompleteEquilibriumDeclaration =
Storage::hasCompleteEquilibriumDeclaration;
template <models::SpecificationRole Role>
using SpecificationsForRole = models::SpecificationsForRoleT<Role, SpecificationTypes>;
template <models::SpecificationRole Role>
requires models::HasUniqueSpecificationForRole<Role, SpecificationTypes>
using SpecificationForRole = models::SpecificationForRoleT<Role, SpecificationTypes>;
template <models::SpecificationRole Role>
static constexpr std::size_t specificationRoleCount = models::specificationRoleCount<Role, SpecificationTypes>;
template <models::SpecificationRole Role>
static constexpr bool hasSpecificationsForRole = models::HasSpecificationsForRole<Role, SpecificationTypes>;
template <models::SpecificationRole Role>
static constexpr bool hasUniqueSpecificationForRole =
models::HasUniqueSpecificationForRole<Role, SpecificationTypes>;
template <typename... Arguments>
requires std::constructible_from<
Storage,
Arguments...>
requires std::constructible_from<Storage, Arguments...>
explicit StellarModel(Arguments &&...arguments) : m_specifications(std::forward<Arguments>(arguments)...) {
}
@@ -41,6 +61,25 @@ export namespace mean_field::model {
template <models::ModelSpecification Specification>
static constexpr bool containsSpecification = Storage::template containsSpecification<Specification>;
template <models::SpecificationRole Role>
requires models::HasUniqueSpecificationForRole<Role, SpecificationTypes>
[[nodiscard]] const models::SpecificationForRoleT<Role, SpecificationTypes> &
specificationForRole() const noexcept {
using Specification = models::SpecificationForRoleT<Role, SpecificationTypes>;
return specification<Specification>();
}
[[nodiscard]] const EquationOfStateType &equationOfState() const noexcept {
return specificationForRole<models::SpecificationRole::constitutive_law>();
}
template <typename = void>
requires models::HasUniqueSpecificationForRole<models::SpecificationRole::boundary_condition,
SpecificationTypes>
[[nodiscard]] const auto &surfaceCondition() const noexcept {
return specificationForRole<models::SpecificationRole::boundary_condition>();
}
[[nodiscard]] static constexpr std::span<const models::RuntimeSpecificationDescriptor>
runtimeSpecificationDescriptors() noexcept {
return Storage::runtimeSpecificationDescriptors();
@@ -56,11 +95,69 @@ export namespace mean_field::model {
-> StellarModel<models::SpecificationSet<std::remove_cvref_t<Specifications>...>>;
namespace detail {
template <typename Candidate> struct IsStellarModel : std::false_type { };
template <typename Candidate, typename = void> struct IsStellarModel : std::false_type {};
template <typename SpecificationSet> struct IsStellarModel<StellarModel<SpecificationSet>> : std::true_type { };
template <typename SpecificationSet>
struct IsStellarModel<
StellarModel<SpecificationSet>,
std::void_t<typename StellarModel<SpecificationSet>::SpecificationTypes,
typename StellarModel<SpecificationSet>::OperatorSignature,
decltype(StellarModel<SpecificationSet>::specificationCount),
decltype(StellarModel<SpecificationSet>::hasCompleteEquilibriumDeclaration)>>
: std::true_type {};
template <models::SpecificationRole Role, typename Candidate, bool = IsStellarModel<Candidate>::value>
struct StellarModelRoleSelection {
using Types = models::ModelTypeList<>;
static constexpr std::size_t count = 0;
};
template <models::SpecificationRole Role, typename Candidate>
struct StellarModelRoleSelection<Role, Candidate, true> {
using Types = models::SpecificationsForRoleT<Role, typename Candidate::SpecificationTypes>;
static constexpr std::size_t count =
models::specificationRoleCount<Role, typename Candidate::SpecificationTypes>;
};
} // namespace detail
template <typename Candidate>
concept StellarModelType = detail::IsStellarModel<std::remove_cvref_t<Candidate>>::value;
template <models::SpecificationRole Role, typename Candidate>
inline constexpr std::size_t specificationRoleCount =
detail::StellarModelRoleSelection<Role, std::remove_cvref_t<Candidate>>::count;
template <models::SpecificationRole Role, typename Candidate>
concept HasSpecificationsForRole = StellarModelType<Candidate> && specificationRoleCount<Role, Candidate> > 0;
template <models::SpecificationRole Role, typename Candidate>
concept HasUniqueSpecificationForRole = StellarModelType<Candidate> && specificationRoleCount<Role, Candidate> == 1;
template <models::SpecificationRole Role, typename Candidate>
requires StellarModelType<Candidate>
using SpecificationsForRoleT =
typename detail::StellarModelRoleSelection<Role, std::remove_cvref_t<Candidate>>::Types;
template <models::SpecificationRole Role, typename Candidate>
requires HasUniqueSpecificationForRole<Role, Candidate>
using SpecificationForRoleT =
models::SpecificationForRoleT<Role, typename std::remove_cvref_t<Candidate>::SpecificationTypes>;
template <typename Candidate>
concept HasEquationOfState = HasUniqueSpecificationForRole<models::SpecificationRole::constitutive_law, Candidate>;
template <typename Candidate>
concept HasSurfaceCondition = HasSpecificationsForRole<models::SpecificationRole::boundary_condition, Candidate>;
template <typename Candidate>
concept HasUniqueSurfaceCondition =
HasUniqueSpecificationForRole<models::SpecificationRole::boundary_condition, Candidate>;
template <HasEquationOfState Candidate>
using EquationOfStateType = SpecificationForRoleT<models::SpecificationRole::constitutive_law, Candidate>;
template <HasUniqueSurfaceCondition Candidate>
using SurfaceConditionType = SpecificationForRoleT<models::SpecificationRole::boundary_condition, Candidate>;
} // namespace mean_field::model