feat(libmeanfield): variadic refactor
also added normaliztion operator
This commit is contained in:
590
libmeanfield/impl/operators/prepared_angular_momentum.cpp
Normal file
590
libmeanfield/impl/operators/prepared_angular_momentum.cpp
Normal file
@@ -0,0 +1,590 @@
|
||||
module;
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <utility>
|
||||
|
||||
#include <mfem.hpp>
|
||||
|
||||
module mean_field;
|
||||
|
||||
import :operators.prepared_angular_momentum;
|
||||
|
||||
namespace {
|
||||
using DomainSchema = mean_field::utils::domain::CoreEnvelopeVacuumDomainSchema;
|
||||
|
||||
[[nodiscard]] bool is_vacuum_attribute(const int attribute) {
|
||||
return DomainSchema::template attribute_belongs_to<mean_field::utils::domain::Vacuum>(attribute);
|
||||
}
|
||||
|
||||
void validate_finite_vector(const mfem::Vector &vector, const char *message) {
|
||||
for (int index = 0; index < vector.Size(); ++index) {
|
||||
MFEM_VERIFY(std::isfinite(vector(index)), message);
|
||||
}
|
||||
}
|
||||
|
||||
void true_to_local(
|
||||
const mfem::ParFiniteElementSpace &finiteElementSpace,
|
||||
const mfem::Vector &trueVector,
|
||||
mfem::Vector &localVector
|
||||
) {
|
||||
MFEM_VERIFY(trueVector.Size() == finiteElementSpace.GetTrueVSize(), "True vector has the wrong size.");
|
||||
localVector.SetSize(finiteElementSpace.GetVSize());
|
||||
const mfem::Operator *prolongation = finiteElementSpace.GetProlongationMatrix();
|
||||
if (prolongation != nullptr) {
|
||||
prolongation->Mult(trueVector, localVector);
|
||||
} else {
|
||||
localVector = trueVector;
|
||||
}
|
||||
}
|
||||
|
||||
[[nodiscard]] const mfem::IntegrationRule &get_moment_of_inertia_rule(
|
||||
const mean_field::fem::FEM &f,
|
||||
const mfem::FiniteElement &densityElement,
|
||||
const mfem::ElementTransformation &transformation
|
||||
) {
|
||||
using DensityField = mean_field::field::Field<mean_field::field::Density>;
|
||||
MFEM_VERIFY(
|
||||
densityElement.GetOrder() == mean_field::field::Density::Scalar::familyOrder,
|
||||
"The angular-momentum element does not match the registered density field."
|
||||
);
|
||||
const mean_field::quadrature::Query query =
|
||||
DensityField::make_query<mean_field::field::Density::Form::Quadrupole>(
|
||||
mean_field::quadrature::QuadratureRole::discretization,
|
||||
transformation.OrderW(),
|
||||
std::array<int, 1>{2},
|
||||
mean_field::utils::DOMAINS::STELLAR,
|
||||
mean_field::quadrature::MappingKind::general
|
||||
);
|
||||
const auto resolution = f.quadratureFactory->get(query, transformation.GetGeometryType());
|
||||
MFEM_VERIFY(
|
||||
resolution.integration_rule != nullptr,
|
||||
"The quadrature policy did not return an angular-momentum integration rule."
|
||||
);
|
||||
return *resolution.integration_rule;
|
||||
}
|
||||
|
||||
void validate_shared_gravity_revisions(
|
||||
const mean_field::operators::context::gravity_field::GravityFieldLinearizationContext &gravityContext,
|
||||
const mean_field::operators::AngularMomentumDependencies &dependencies
|
||||
) {
|
||||
MFEM_VERIFY(
|
||||
gravityContext.IsPrepared(),
|
||||
"PreparedAngularMomentumOperator requires the shared gravity context to be prepared first."
|
||||
);
|
||||
const auto &revisions = gravityContext.GetRevisions();
|
||||
MFEM_VERIFY(
|
||||
revisions.discretization.value == dependencies.discretization.revision &&
|
||||
revisions.density.value == dependencies.density.revision &&
|
||||
revisions.displacement.value == dependencies.displacement.revision,
|
||||
"PreparedAngularMomentumOperator received revisions that do not match the shared gravity context."
|
||||
);
|
||||
}
|
||||
|
||||
void validate_identity_transition(
|
||||
const mean_field::operators::AngularMomentumDependencyStamp &prepared,
|
||||
const mean_field::operators::AngularMomentumDependencyStamp &requested,
|
||||
const char *message
|
||||
) {
|
||||
MFEM_VERIFY(prepared.identity == requested.identity || prepared.revision != requested.revision, message);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
namespace mean_field::operators {
|
||||
PreparedAngularMomentumOperator::PreparedAngularMomentumOperator(
|
||||
const fem::FEM &f,
|
||||
const mapping::DomainMapper &domainMapper,
|
||||
const context::gravity_field::GravityFieldLinearizationContext &gravityContext,
|
||||
models::CompiledFixedAngularMomentum constraint
|
||||
)
|
||||
: m_fem(f),
|
||||
m_domainMapper(domainMapper),
|
||||
m_gravityContext(gravityContext),
|
||||
m_constraint(std::move(constraint)) {
|
||||
MFEM_VERIFY(m_fem.mesh != nullptr, "PreparedAngularMomentumOperator requires a mesh.");
|
||||
MFEM_VERIFY(
|
||||
m_fem.mesh->Dimension() == 3 && m_domainMapper.GetDimension() == 3,
|
||||
"PreparedAngularMomentumOperator currently requires a three-dimensional mapped domain."
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
m_fem.densityFes != nullptr && m_fem.displacementFes != nullptr &&
|
||||
m_fem.compactificationFes != nullptr && m_fem.compactificationCoordinate != nullptr &&
|
||||
m_fem.quadratureFactory != nullptr,
|
||||
"PreparedAngularMomentumOperator requires density, displacement, compactification, and quadrature data."
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
m_gravityContext.GetDensityMap().full_size() == m_fem.densityFes->GetTrueVSize() &&
|
||||
m_gravityContext.GetDisplacementMap().full_size() == m_fem.displacementFes->GetTrueVSize(),
|
||||
"PreparedAngularMomentumOperator received incompatible shared FieldDof maps."
|
||||
);
|
||||
m_densityVariationTrue.SetSize(m_gravityContext.GetDensityMap().full_size());
|
||||
m_displacementVariationTrue.SetSize(m_gravityContext.GetDisplacementMap().full_size());
|
||||
}
|
||||
|
||||
PreparedAngularMomentumReport PreparedAngularMomentumOperator::Prepare(
|
||||
const double angularVelocity,
|
||||
const AngularMomentumDependencies &dependencies
|
||||
) {
|
||||
MFEM_VERIFY(
|
||||
std::isfinite(angularVelocity),
|
||||
"PreparedAngularMomentumOperator requires a finite angular-velocity coordinate."
|
||||
);
|
||||
validate_shared_gravity_revisions(m_gravityContext, dependencies);
|
||||
|
||||
if (m_isPrepared) {
|
||||
validate_identity_transition(
|
||||
m_preparedDependencies.discretization,
|
||||
dependencies.discretization,
|
||||
"A new angular-momentum discretization identity must change its revision."
|
||||
);
|
||||
validate_identity_transition(
|
||||
m_preparedDependencies.density,
|
||||
dependencies.density,
|
||||
"A new angular-momentum density identity must change its revision."
|
||||
);
|
||||
validate_identity_transition(
|
||||
m_preparedDependencies.displacement,
|
||||
dependencies.displacement,
|
||||
"A new angular-momentum displacement identity must change its revision."
|
||||
);
|
||||
validate_identity_transition(
|
||||
m_preparedDependencies.rotation,
|
||||
dependencies.rotation,
|
||||
"A new angular-momentum rotation identity must change its revision."
|
||||
);
|
||||
}
|
||||
|
||||
const bool rebuildStaticPlan =
|
||||
!m_isPrepared || dependencies.discretization != m_preparedDependencies.discretization;
|
||||
const bool refreshGeometry =
|
||||
rebuildStaticPlan || dependencies.displacement != m_preparedDependencies.displacement;
|
||||
const bool refreshDensity = rebuildStaticPlan || dependencies.density != m_preparedDependencies.density;
|
||||
const bool updateAngularVelocity =
|
||||
!m_isPrepared || dependencies.rotation != m_preparedDependencies.rotation ||
|
||||
angularVelocity != m_angularVelocity;
|
||||
|
||||
m_isPrepared = false;
|
||||
PreparedAngularMomentumReport report;
|
||||
if (rebuildStaticPlan) {
|
||||
BuildStaticPlan();
|
||||
report.rebuiltStaticPlan = true;
|
||||
}
|
||||
if (refreshGeometry) {
|
||||
RefreshGeometry(m_gravityContext.GetGeometryContext().GetDisplacementTrue());
|
||||
report.refreshedGeometry = true;
|
||||
}
|
||||
if (refreshDensity) {
|
||||
RefreshDensity(m_gravityContext.GetDensityTrue());
|
||||
report.refreshedDensity = true;
|
||||
}
|
||||
if (updateAngularVelocity) {
|
||||
m_angularVelocity = angularVelocity;
|
||||
report.updatedAngularVelocity = true;
|
||||
}
|
||||
if (refreshGeometry || refreshDensity || updateAngularVelocity) {
|
||||
AssembleResidual();
|
||||
report.assembledResidual = true;
|
||||
}
|
||||
|
||||
m_preparedDependencies = dependencies;
|
||||
m_isPrepared = true;
|
||||
return report;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::BuildStaticPlan() {
|
||||
m_elements.clear();
|
||||
m_elements.reserve(m_fem.mesh->GetNE());
|
||||
int localStellarElementCount = 0;
|
||||
for (int elementId = 0; elementId < m_fem.mesh->GetNE(); ++elementId) {
|
||||
mfem::ElementTransformation *transformation = m_fem.mesh->GetElementTransformation(elementId);
|
||||
MFEM_VERIFY(transformation != nullptr, "Angular-momentum preparation received a null transformation.");
|
||||
if (is_vacuum_attribute(transformation->Attribute)) {
|
||||
continue;
|
||||
}
|
||||
++localStellarElementCount;
|
||||
m_elements.emplace_back();
|
||||
ElementPAData &data = m_elements.back();
|
||||
data.elementId = elementId;
|
||||
data.densityDofTransformation = m_fem.densityFes->GetElementDofs(elementId, data.densityDofs);
|
||||
data.displacementDofTransformation =
|
||||
m_fem.displacementFes->GetElementVDofs(elementId, data.displacementDofs);
|
||||
data.compactificationDofTransformation =
|
||||
m_fem.compactificationFes->GetElementDofs(elementId, data.compactificationDofs);
|
||||
|
||||
const mfem::FiniteElement &densityElement = *m_fem.densityFes->GetFE(elementId);
|
||||
const mfem::IntegrationRule &integrationRule =
|
||||
get_moment_of_inertia_rule(m_fem, densityElement, *transformation);
|
||||
data.quadraturePoints.resize(integrationRule.GetNPoints());
|
||||
for (int quadraturePoint = 0; quadraturePoint < integrationRule.GetNPoints(); ++quadraturePoint) {
|
||||
QuadraturePointData &point = data.quadraturePoints[quadraturePoint];
|
||||
point.integrationPoint = integrationRule.IntPoint(quadraturePoint);
|
||||
point.densityShape.SetSize(densityElement.GetDof());
|
||||
densityElement.CalcShape(point.integrationPoint, point.densityShape);
|
||||
}
|
||||
}
|
||||
int globalStellarElementCount = 0;
|
||||
MPI_Allreduce(
|
||||
&localStellarElementCount,
|
||||
&globalStellarElementCount,
|
||||
1,
|
||||
MPI_INT,
|
||||
MPI_SUM,
|
||||
m_fem.mesh->GetComm()
|
||||
);
|
||||
MFEM_VERIFY(globalStellarElementCount > 0, "PreparedAngularMomentumOperator found no stellar elements.");
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::RefreshGeometry(const mfem::Vector &displacement) {
|
||||
MFEM_VERIFY(
|
||||
displacement.Size() == m_fem.displacementFes->GetTrueVSize(),
|
||||
"Angular-momentum geometry has the wrong displacement size."
|
||||
);
|
||||
validate_finite_vector(displacement, "Angular-momentum geometry contains a non-finite displacement.");
|
||||
mfem::Vector displacementLocal;
|
||||
true_to_local(*m_fem.displacementFes, displacement, displacementLocal);
|
||||
mapping::DomainMapper::Workspace workspace(m_fem.mesh->Dimension());
|
||||
|
||||
for (ElementPAData &data : m_elements) {
|
||||
displacementLocal.GetSubVector(data.displacementDofs, data.baseDisplacement);
|
||||
m_fem.compactificationCoordinate->GetSubVector(data.compactificationDofs, data.compactification);
|
||||
if (data.displacementDofTransformation != nullptr) {
|
||||
data.displacementDofTransformation->InvTransformPrimal(data.baseDisplacement);
|
||||
}
|
||||
if (data.compactificationDofTransformation != nullptr) {
|
||||
data.compactificationDofTransformation->InvTransformPrimal(data.compactification);
|
||||
}
|
||||
const mfem::FiniteElement &displacementElement = *m_fem.displacementFes->GetFE(data.elementId);
|
||||
const mfem::FiniteElement &compactificationElement = *m_fem.compactificationFes->GetFE(data.elementId);
|
||||
const mapping::ElementDisplacementData displacementData =
|
||||
mapping::ElementDisplacementDataFromElementVDofs(displacementElement, data.baseDisplacement);
|
||||
const mapping::ElementCompactificationData compactificationData(
|
||||
compactificationElement,
|
||||
data.compactification
|
||||
);
|
||||
const mapping::ElementMappingData mappingData{
|
||||
.displacement = displacementData,
|
||||
.compactification = compactificationData
|
||||
};
|
||||
mfem::ElementTransformation *transformation = m_fem.mesh->GetElementTransformation(data.elementId);
|
||||
for (QuadraturePointData &point : data.quadraturePoints) {
|
||||
const mapping::MappingStatus status = m_domainMapper.EvaluateVolume(
|
||||
mappingData,
|
||||
*transformation,
|
||||
point.integrationPoint,
|
||||
workspace,
|
||||
point.mappingContext
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
status == mapping::MappingStatus::valid && !point.mappingContext.mapping.compactified,
|
||||
"Mapped angular-momentum geometry is invalid. Element: " << data.elementId
|
||||
);
|
||||
point.cylindricalRadiusSquared =
|
||||
CylindricalRadiusSquared(point.mappingContext.mapping.physical_position);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::RefreshDensity(const mfem::Vector &density) {
|
||||
MFEM_VERIFY(
|
||||
density.Size() == m_fem.densityFes->GetTrueVSize(),
|
||||
"Angular-momentum density has the wrong size."
|
||||
);
|
||||
validate_finite_vector(density, "Angular-momentum density contains a non-finite value.");
|
||||
mfem::Vector densityLocal;
|
||||
true_to_local(*m_fem.densityFes, density, densityLocal);
|
||||
mfem::Vector elementDensity;
|
||||
for (ElementPAData &data : m_elements) {
|
||||
densityLocal.GetSubVector(data.densityDofs, elementDensity);
|
||||
if (data.densityDofTransformation != nullptr) {
|
||||
data.densityDofTransformation->InvTransformPrimal(elementDensity);
|
||||
}
|
||||
for (QuadraturePointData &point : data.quadraturePoints) {
|
||||
point.density = elementDensity * point.densityShape;
|
||||
MFEM_VERIFY(std::isfinite(point.density), "Angular-momentum quadrature density is non-finite.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::AssembleResidual() {
|
||||
double localMomentOfInertia = 0.0;
|
||||
for (const ElementPAData &data : m_elements) {
|
||||
for (const QuadraturePointData &point : data.quadraturePoints) {
|
||||
localMomentOfInertia += point.density * point.cylindricalRadiusSquared *
|
||||
point.mappingContext.quadrature.weight;
|
||||
}
|
||||
}
|
||||
m_momentOfInertia = GlobalSum(localMomentOfInertia);
|
||||
MFEM_VERIFY(
|
||||
std::isfinite(m_momentOfInertia) && m_momentOfInertia >= 0.0,
|
||||
"PreparedAngularMomentumOperator assembled an invalid moment of inertia."
|
||||
);
|
||||
m_currentAngularMomentum = m_angularVelocity * m_momentOfInertia;
|
||||
m_cachedResidual.SetSize(1);
|
||||
m_cachedResidual(0) = m_currentAngularMomentum - m_constraint.targetAngularMomentum().value();
|
||||
++m_preparationCount;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::BuildResidual(mfem::Vector &residual) const {
|
||||
VerifyPrepared();
|
||||
residual = m_cachedResidual;
|
||||
++m_residualApplicationCount;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::EvaluateDensityMomentActionLocal(
|
||||
const mfem::Vector &densityVariation
|
||||
) const {
|
||||
MFEM_VERIFY(
|
||||
densityVariation.Size() == m_fem.densityFes->GetTrueVSize(),
|
||||
"Angular-momentum density action has the wrong true-vector size."
|
||||
);
|
||||
true_to_local(*m_fem.densityFes, densityVariation, m_densityVariationLocal);
|
||||
double localAction = 0.0;
|
||||
for (const ElementPAData &data : m_elements) {
|
||||
m_densityVariationLocal.GetSubVector(data.densityDofs, m_elementDensityVariation);
|
||||
if (data.densityDofTransformation != nullptr) {
|
||||
data.densityDofTransformation->InvTransformPrimal(m_elementDensityVariation);
|
||||
}
|
||||
for (const QuadraturePointData &point : data.quadraturePoints) {
|
||||
localAction += (m_elementDensityVariation * point.densityShape) *
|
||||
point.cylindricalRadiusSquared * point.mappingContext.quadrature.weight;
|
||||
}
|
||||
}
|
||||
return localAction;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::EvaluateDisplacementMomentActionLocal(
|
||||
const mfem::Vector &displacementVariation
|
||||
) const {
|
||||
MFEM_VERIFY(
|
||||
displacementVariation.Size() == m_fem.displacementFes->GetTrueVSize(),
|
||||
"Angular-momentum displacement action has the wrong true-vector size."
|
||||
);
|
||||
true_to_local(*m_fem.displacementFes, displacementVariation, m_displacementVariationLocal);
|
||||
mapping::DomainMapper::Workspace workspace(m_fem.mesh->Dimension());
|
||||
mapping::VolumeMappingVariation variation;
|
||||
double localAction = 0.0;
|
||||
for (const ElementPAData &data : m_elements) {
|
||||
m_displacementVariationLocal.GetSubVector(data.displacementDofs, m_elementDisplacementVariation);
|
||||
if (data.displacementDofTransformation != nullptr) {
|
||||
data.displacementDofTransformation->InvTransformPrimal(m_elementDisplacementVariation);
|
||||
}
|
||||
const mfem::FiniteElement &displacementElement = *m_fem.displacementFes->GetFE(data.elementId);
|
||||
const mfem::FiniteElement &compactificationElement = *m_fem.compactificationFes->GetFE(data.elementId);
|
||||
const mapping::ElementDisplacementData baseDisplacementData =
|
||||
mapping::ElementDisplacementDataFromElementVDofs(displacementElement, data.baseDisplacement);
|
||||
const mapping::ElementDisplacementData directionData =
|
||||
mapping::ElementDisplacementDataFromElementVDofs(displacementElement, m_elementDisplacementVariation);
|
||||
const mapping::ElementCompactificationData compactificationData(
|
||||
compactificationElement,
|
||||
data.compactification
|
||||
);
|
||||
const mapping::ElementMappingData mappingData{
|
||||
.displacement = baseDisplacementData,
|
||||
.compactification = compactificationData
|
||||
};
|
||||
mfem::ElementTransformation *transformation = m_fem.mesh->GetElementTransformation(data.elementId);
|
||||
for (const QuadraturePointData &point : data.quadraturePoints) {
|
||||
const mapping::MappingStatus status = m_domainMapper.EvaluateVolumeVariation(
|
||||
mappingData,
|
||||
directionData,
|
||||
*transformation,
|
||||
point.integrationPoint,
|
||||
point.mappingContext,
|
||||
workspace,
|
||||
variation
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
status == mapping::MappingStatus::valid,
|
||||
"Mapped angular-momentum variation is invalid. Element: " << data.elementId
|
||||
);
|
||||
const double radiusSquaredVariation = CylindricalRadiusSquaredVariation(
|
||||
point.mappingContext.mapping.physical_position,
|
||||
variation.mapping.physical_position_variation
|
||||
);
|
||||
localAction += point.density *
|
||||
(radiusSquaredVariation * point.mappingContext.quadrature.weight +
|
||||
point.cylindricalRadiusSquared * variation.weight_variation);
|
||||
}
|
||||
}
|
||||
return localAction;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::ApplyDensityJacobianAction(
|
||||
const mfem::Vector &densityVariation,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(
|
||||
densityVariation.Size() == m_gravityContext.GetDensityMap().reduced_size(),
|
||||
"Angular-momentum density action has the wrong reduced size."
|
||||
);
|
||||
validate_finite_vector(densityVariation, "Angular-momentum density direction is non-finite.");
|
||||
m_gravityContext.GetDensityMap().scatter(densityVariation, m_densityVariationTrue);
|
||||
action.SetSize(1);
|
||||
action(0) = m_angularVelocity * GlobalSum(EvaluateDensityMomentActionLocal(m_densityVariationTrue));
|
||||
++m_actionStatistics.densityApplications;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::ApplyDisplacementJacobianAction(
|
||||
const mfem::Vector &displacementVariation,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(
|
||||
displacementVariation.Size() == m_gravityContext.GetDisplacementMap().reduced_size(),
|
||||
"Angular-momentum displacement action has the wrong reduced size."
|
||||
);
|
||||
validate_finite_vector(displacementVariation, "Angular-momentum displacement direction is non-finite.");
|
||||
m_gravityContext.GetDisplacementMap().scatter(displacementVariation, m_displacementVariationTrue);
|
||||
action.SetSize(1);
|
||||
action(0) = m_angularVelocity *
|
||||
GlobalSum(EvaluateDisplacementMomentActionLocal(m_displacementVariationTrue));
|
||||
++m_actionStatistics.displacementApplications;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::ApplyAngularVelocityJacobianAction(
|
||||
const double angularVelocityVariation,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(std::isfinite(angularVelocityVariation), "Angular-velocity direction is non-finite.");
|
||||
action.SetSize(1);
|
||||
action(0) = m_momentOfInertia * angularVelocityVariation;
|
||||
++m_actionStatistics.angularVelocityApplications;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::ApplyCompleteJacobianAction(
|
||||
const mfem::Vector &densityVariation,
|
||||
const mfem::Vector &displacementVariation,
|
||||
const double angularVelocityVariation,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(
|
||||
densityVariation.Size() == m_gravityContext.GetDensityMap().reduced_size() &&
|
||||
displacementVariation.Size() == m_gravityContext.GetDisplacementMap().reduced_size(),
|
||||
"Angular-momentum complete action has incompatible reduced coordinates."
|
||||
);
|
||||
validate_finite_vector(densityVariation, "Angular-momentum density direction is non-finite.");
|
||||
validate_finite_vector(displacementVariation, "Angular-momentum displacement direction is non-finite.");
|
||||
MFEM_VERIFY(std::isfinite(angularVelocityVariation), "Angular-velocity direction is non-finite.");
|
||||
m_gravityContext.GetDensityMap().scatter(densityVariation, m_densityVariationTrue);
|
||||
m_gravityContext.GetDisplacementMap().scatter(displacementVariation, m_displacementVariationTrue);
|
||||
const double localMomentAction = EvaluateDensityMomentActionLocal(m_densityVariationTrue) +
|
||||
EvaluateDisplacementMomentActionLocal(m_displacementVariationTrue);
|
||||
action.SetSize(1);
|
||||
action(0) = m_angularVelocity * GlobalSum(localMomentAction) +
|
||||
m_momentOfInertia * angularVelocityVariation;
|
||||
++m_actionStatistics.completeApplications;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::CylindricalRadiusSquared(
|
||||
const mfem::Vector &physicalPosition
|
||||
) const noexcept {
|
||||
const auto &axis = m_constraint.specification().axis();
|
||||
const auto ¢er = m_constraint.specification().center();
|
||||
double radiusSquared = 0.0;
|
||||
double axialPosition = 0.0;
|
||||
for (int component = 0; component < 3; ++component) {
|
||||
const double relative = physicalPosition(component) - center[static_cast<std::size_t>(component)];
|
||||
radiusSquared += relative * relative;
|
||||
axialPosition += axis[static_cast<std::size_t>(component)] * relative;
|
||||
}
|
||||
return std::max(0.0, radiusSquared - axialPosition * axialPosition);
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::CylindricalRadiusSquaredVariation(
|
||||
const mfem::Vector &physicalPosition,
|
||||
const mfem::Vector &physicalPositionVariation
|
||||
) const noexcept {
|
||||
const auto &axis = m_constraint.specification().axis();
|
||||
const auto ¢er = m_constraint.specification().center();
|
||||
double relativeDotVariation = 0.0;
|
||||
double axialPosition = 0.0;
|
||||
double axialVariation = 0.0;
|
||||
for (int component = 0; component < 3; ++component) {
|
||||
const double relative = physicalPosition(component) - center[static_cast<std::size_t>(component)];
|
||||
relativeDotVariation += relative * physicalPositionVariation(component);
|
||||
axialPosition += axis[static_cast<std::size_t>(component)] * relative;
|
||||
axialVariation += axis[static_cast<std::size_t>(component)] * physicalPositionVariation(component);
|
||||
}
|
||||
return 2.0 * (relativeDotVariation - axialPosition * axialVariation);
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::GlobalSum(const double localValue) const {
|
||||
double globalValue = 0.0;
|
||||
MPI_Allreduce(&localValue, &globalValue, 1, MPI_DOUBLE, MPI_SUM, m_fem.mesh->GetComm());
|
||||
return globalValue;
|
||||
}
|
||||
|
||||
bool PreparedAngularMomentumOperator::IsPrepared() const noexcept {
|
||||
if (!m_isPrepared || !m_gravityContext.IsPrepared()) {
|
||||
return false;
|
||||
}
|
||||
const auto &revisions = m_gravityContext.GetRevisions();
|
||||
return revisions.discretization.value == m_preparedDependencies.discretization.revision &&
|
||||
revisions.density.value == m_preparedDependencies.density.revision &&
|
||||
revisions.displacement.value == m_preparedDependencies.displacement.revision;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::GetMomentOfInertia() const {
|
||||
VerifyPrepared();
|
||||
return m_momentOfInertia;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::GetAngularVelocity() const {
|
||||
VerifyPrepared();
|
||||
return m_angularVelocity;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::GetCurrentAngularMomentum() const {
|
||||
VerifyPrepared();
|
||||
return m_currentAngularMomentum;
|
||||
}
|
||||
|
||||
double PreparedAngularMomentumOperator::GetTargetAngularMomentum() const noexcept {
|
||||
return m_constraint.targetAngularMomentum().value();
|
||||
}
|
||||
|
||||
physics::RigidRotation PreparedAngularMomentumOperator::GetRotation() const {
|
||||
VerifyPrepared();
|
||||
return m_constraint.makeRotation(m_angularVelocity);
|
||||
}
|
||||
|
||||
AngularMomentumConstraintReport PreparedAngularMomentumOperator::GetConstraintReport() const {
|
||||
VerifyPrepared();
|
||||
const double target = GetTargetAngularMomentum();
|
||||
const double residual = m_currentAngularMomentum - target;
|
||||
return {
|
||||
.targetAngularMomentum = target,
|
||||
.achievedAngularMomentum = m_currentAngularMomentum,
|
||||
.momentOfInertia = m_momentOfInertia,
|
||||
.angularVelocity = m_angularVelocity,
|
||||
.dimensionalResidual = residual,
|
||||
.scaledResidual = residual / std::max(std::abs(target), 1.0e-300)
|
||||
};
|
||||
}
|
||||
|
||||
std::uint64_t PreparedAngularMomentumOperator::GetPreparationCount() const noexcept {
|
||||
return m_preparationCount;
|
||||
}
|
||||
|
||||
std::uint64_t PreparedAngularMomentumOperator::GetResidualApplicationCount() const noexcept {
|
||||
return m_residualApplicationCount;
|
||||
}
|
||||
|
||||
const PreparedAngularMomentumActionStatistics &
|
||||
PreparedAngularMomentumOperator::GetActionStatistics() const noexcept {
|
||||
return m_actionStatistics;
|
||||
}
|
||||
|
||||
const models::CompiledFixedAngularMomentum &
|
||||
PreparedAngularMomentumOperator::GetCompiledConstraint() const noexcept {
|
||||
return m_constraint;
|
||||
}
|
||||
|
||||
void PreparedAngularMomentumOperator::VerifyPrepared() const {
|
||||
MFEM_VERIFY(IsPrepared(), "The angular-momentum invariant must be prepared before application.");
|
||||
}
|
||||
} // namespace mean_field::operators
|
||||
@@ -1,223 +0,0 @@
|
||||
module;
|
||||
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
|
||||
#include <mfem.hpp>
|
||||
|
||||
module mean_field;
|
||||
|
||||
import :operators.prepared_central_density_stellar_equilibrium;
|
||||
|
||||
namespace {
|
||||
using DomainSchema = mean_field::utils::domain::CoreEnvelopeVacuumDomainSchema;
|
||||
using PhysicalForm = mean_field::utils::blocks::surface_deformed_stellar_equilibrium_form;
|
||||
using BorderedForm = mean_field::operators::CentralDensityStellarEquilibriumForm;
|
||||
|
||||
[[nodiscard]] std::array<
|
||||
int,
|
||||
BorderedForm::value_block_count>
|
||||
make_value_sizes(const mean_field::operators::StellarEquilibriumLayout &physicalLayout) {
|
||||
std::array<int, BorderedForm::value_block_count> sizes{};
|
||||
for (int block = 0; block < PhysicalForm::value_block_count; ++block) {
|
||||
sizes[block] = physicalLayout.value_offsets()[block + 1] - physicalLayout.value_offsets()[block];
|
||||
}
|
||||
sizes[PhysicalForm::value_block_count] = 1;
|
||||
return sizes;
|
||||
}
|
||||
|
||||
[[nodiscard]] std::array<
|
||||
int,
|
||||
BorderedForm::residual_block_count>
|
||||
make_residual_sizes(const mean_field::operators::StellarEquilibriumLayout &physicalLayout) {
|
||||
std::array<int, BorderedForm::residual_block_count> sizes{};
|
||||
for (int block = 0; block < PhysicalForm::residual_block_count; ++block) {
|
||||
sizes[block] = physicalLayout.residual_offsets()[block + 1] - physicalLayout.residual_offsets()[block];
|
||||
}
|
||||
sizes[PhysicalForm::residual_block_count] = 1;
|
||||
return sizes;
|
||||
}
|
||||
|
||||
[[nodiscard]] mean_field::operators::CentralDensityDependencies
|
||||
make_phase_dependencies(const mean_field::operators::StellarEquilibriumDependencies &dependencies) {
|
||||
return {.enthalpy = {.identity = dependencies.enthalpy.identity, .revision = dependencies.enthalpy.revision}};
|
||||
}
|
||||
|
||||
void validate_finite_scalar(
|
||||
const double value,
|
||||
const char *message
|
||||
) {
|
||||
MFEM_VERIFY(std::isfinite(value), message);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
namespace mean_field::operators {
|
||||
field::FieldPointDofMap PreparedCentralDensityStellarEquilibriumOperator::MakeCenterDofMap(const fem::FEM &f) {
|
||||
MFEM_VERIFY(
|
||||
f.mesh != nullptr && f.enthalpyFes != nullptr,
|
||||
"The central-density phase requires the mesh and enthalpy finite-element space."
|
||||
);
|
||||
const field::FieldDofMap enthalpyMap = field::make_field_dof_map<field::Enthalpy, DomainSchema>(*f.enthalpyFes);
|
||||
mfem::Vector origin(f.mesh->SpaceDimension());
|
||||
origin = 0.0;
|
||||
return field::make_field_point_dof_map<field::Enthalpy>(*f.enthalpyFes, enthalpyMap, origin, 1.0e-12);
|
||||
}
|
||||
|
||||
PreparedCentralDensityStellarEquilibriumOperator::PreparedCentralDensityStellarEquilibriumOperator(
|
||||
fem::FEM &f,
|
||||
std::unique_ptr<PreparedStellarEquilibriumOperator> physicalOperator,
|
||||
models::CompiledFixedCentralDensity centralDensity,
|
||||
field::FieldPointDofMap centerDof
|
||||
)
|
||||
: mfem::Operator(
|
||||
physicalOperator->Height() + 1,
|
||||
physicalOperator->Width() + 1
|
||||
),
|
||||
m_physicalOperator(std::move(physicalOperator)),
|
||||
m_centralDensity(std::move(centralDensity)),
|
||||
m_phaseConstraint(
|
||||
std::move(centerDof),
|
||||
f.mesh->GetComm()
|
||||
),
|
||||
m_rootManifest(
|
||||
make_value_sizes(m_physicalOperator->GetLayout()),
|
||||
make_residual_sizes(m_physicalOperator->GetLayout()),
|
||||
m_physicalOperator->GetTargetMass(),
|
||||
m_physicalOperator->GetSurfaceConstraintOperator().GetPhysicalCondition().targetPressure,
|
||||
m_physicalOperator->GetSurfaceConstraintOperator().GetSurfaceRows().size(),
|
||||
CentralDensityManifestInput{
|
||||
.targetDensity = m_centralDensity.targetDensity().value(),
|
||||
.targetEnthalpy = m_centralDensity.targetEnthalpy().value(),
|
||||
.centerDofCount = 1
|
||||
}
|
||||
) {
|
||||
MFEM_VERIFY(
|
||||
Width() == m_rootManifest.layout().value_offsets().Last() &&
|
||||
Height() == m_rootManifest.layout().residual_offsets().Last(),
|
||||
"The central-density bordered root has inconsistent dimensions."
|
||||
);
|
||||
}
|
||||
|
||||
PreparedCentralDensityStellarEquilibriumReport PreparedCentralDensityStellarEquilibriumOperator::Prepare(
|
||||
const mfem::Vector &state,
|
||||
const StellarEquilibriumDependencies &dependencies,
|
||||
const physics::RigidRotation &rotation
|
||||
) {
|
||||
MFEM_VERIFY(state.Size() == Width(), "The central-density bordered root received a state with the wrong size.");
|
||||
const auto stateView = m_rootManifest.stateView(state);
|
||||
const mfem::Vector enthalpy = stateView.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const mfem::Vector border = stateView.block(utils::blocks::fixed_central_density_phase.central_value_term);
|
||||
validate_finite_scalar(border(0), "The central-density bordered root received a non-finite border value.");
|
||||
|
||||
mfem::Vector physicalState(const_cast<mfem::real_t *>(state.GetData()), m_physicalOperator->Width());
|
||||
|
||||
m_isPrepared = false;
|
||||
PreparedCentralDensityStellarEquilibriumReport report;
|
||||
report.physical = m_physicalOperator->Prepare(physicalState, dependencies, rotation);
|
||||
report.phase =
|
||||
m_phaseConstraint.Prepare(m_centralDensity, enthalpy, border(0), make_phase_dependencies(dependencies));
|
||||
|
||||
if (report.physical.assembledResidual || report.phase.DidAnyWork() || m_cachedResidual.Size() != Height()) {
|
||||
AssembleResidual();
|
||||
report.assembledResidual = true;
|
||||
}
|
||||
|
||||
m_isPrepared = true;
|
||||
return report;
|
||||
}
|
||||
|
||||
void PreparedCentralDensityStellarEquilibriumOperator::AssembleResidual() {
|
||||
mfem::Vector physicalResidual;
|
||||
m_physicalOperator->BuildResidual(physicalResidual);
|
||||
|
||||
m_cachedResidual.SetSize(Height());
|
||||
m_cachedResidual = 0.0;
|
||||
mfem::Vector physicalDestination(m_cachedResidual.GetData(), physicalResidual.Size());
|
||||
physicalDestination = physicalResidual;
|
||||
|
||||
const auto residualView = m_rootManifest.residualView(m_cachedResidual);
|
||||
mfem::Vector enthalpyResidual = residualView.block(utils::blocks::enthalpy_field.specific_term);
|
||||
mfem::Vector phaseResidual = residualView.block(utils::blocks::fixed_central_density_phase.central_value_term);
|
||||
m_phaseConstraint.AddResidual(enthalpyResidual, phaseResidual);
|
||||
}
|
||||
|
||||
void PreparedCentralDensityStellarEquilibriumOperator::BuildResidual(mfem::Vector &residual) const {
|
||||
VerifyPrepared();
|
||||
residual = m_cachedResidual;
|
||||
}
|
||||
|
||||
void PreparedCentralDensityStellarEquilibriumOperator::Mult(
|
||||
const mfem::Vector &direction,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(
|
||||
direction.Size() == Width(), "The central-density bordered root received a direction with the wrong size."
|
||||
);
|
||||
const auto directionView = m_rootManifest.directionView(direction);
|
||||
const mfem::Vector enthalpyDirection = directionView.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const mfem::Vector borderDirection =
|
||||
directionView.block(utils::blocks::fixed_central_density_phase.central_value_term);
|
||||
validate_finite_scalar(
|
||||
borderDirection(0), "The central-density bordered root received a non-finite border direction."
|
||||
);
|
||||
|
||||
mfem::Vector physicalDirection(const_cast<mfem::real_t *>(direction.GetData()), m_physicalOperator->Width());
|
||||
mfem::Vector physicalAction;
|
||||
m_physicalOperator->Mult(physicalDirection, physicalAction);
|
||||
|
||||
action.SetSize(Height());
|
||||
action = 0.0;
|
||||
mfem::Vector physicalDestination(action.GetData(), physicalAction.Size());
|
||||
physicalDestination = physicalAction;
|
||||
|
||||
const auto actionView = m_rootManifest.residualView(action);
|
||||
mfem::Vector enthalpyAction = actionView.block(utils::blocks::enthalpy_field.specific_term);
|
||||
mfem::Vector phaseAction = actionView.block(utils::blocks::fixed_central_density_phase.central_value_term);
|
||||
m_phaseConstraint.ApplyJacobian(
|
||||
{.enthalpyVariation = enthalpyDirection, .borderVariation = borderDirection(0)},
|
||||
{.enthalpyAction = enthalpyAction, .phaseAction = phaseAction}
|
||||
);
|
||||
}
|
||||
|
||||
bool PreparedCentralDensityStellarEquilibriumOperator::IsPrepared() const noexcept {
|
||||
return m_isPrepared && m_physicalOperator->IsPrepared() && m_phaseConstraint.IsPrepared();
|
||||
}
|
||||
|
||||
const CentralDensityStellarEquilibriumLayout &
|
||||
PreparedCentralDensityStellarEquilibriumOperator::GetLayout() const noexcept {
|
||||
return m_rootManifest.layout();
|
||||
}
|
||||
|
||||
const CentralDensityStellarEquilibriumRootManifest &
|
||||
PreparedCentralDensityStellarEquilibriumOperator::GetRootManifest() const noexcept {
|
||||
return m_rootManifest;
|
||||
}
|
||||
|
||||
const PreparedStellarEquilibriumOperator &
|
||||
PreparedCentralDensityStellarEquilibriumOperator::GetPhysicalOperator() const noexcept {
|
||||
return *m_physicalOperator;
|
||||
}
|
||||
|
||||
const PreparedCentralDensityConstraint &
|
||||
PreparedCentralDensityStellarEquilibriumOperator::GetCentralDensityConstraint() const noexcept {
|
||||
return m_phaseConstraint;
|
||||
}
|
||||
|
||||
RootConstraintReport PreparedCentralDensityStellarEquilibriumOperator::GetFixedMassReport() const {
|
||||
VerifyPrepared();
|
||||
return m_physicalOperator->GetFixedMassReport();
|
||||
}
|
||||
|
||||
CentralDensityConstraintReport PreparedCentralDensityStellarEquilibriumOperator::GetCentralDensityReport() const {
|
||||
VerifyPrepared();
|
||||
return m_phaseConstraint.GetConstraintReport();
|
||||
}
|
||||
|
||||
void PreparedCentralDensityStellarEquilibriumOperator::VerifyPrepared() const {
|
||||
MFEM_VERIFY(IsPrepared(), "The central-density bordered root must be prepared before application.");
|
||||
}
|
||||
} // namespace mean_field::operators
|
||||
@@ -903,6 +903,47 @@ namespace mean_field::operators {
|
||||
++m_algebraicJacobianStatistics.bernoulliConstantApplications;
|
||||
}
|
||||
|
||||
void PreparedHydrostaticEquilibriumOperator::ApplyRotationAmplitudeJacobianAction(
|
||||
const double fractionalAngularVelocityVariation,
|
||||
mfem::Vector &action
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
MFEM_VERIFY(
|
||||
std::isfinite(fractionalAngularVelocityVariation),
|
||||
"Prepared hydrostatic rotation-amplitude Jacobian received a non-finite variation."
|
||||
);
|
||||
|
||||
mfem::Vector localAction(m_fem.enthalpyFes->GetVSize());
|
||||
localAction = 0.0;
|
||||
mfem::Vector weightedVariation;
|
||||
mfem::Vector elementAction;
|
||||
|
||||
for (const ElementPAData &data : m_elements) {
|
||||
const int quadraturePointCount = data.quadratureWeights.Size();
|
||||
MFEM_VERIFY(
|
||||
data.rotationPotential.Size() == quadraturePointCount,
|
||||
"Prepared hydrostatic rotation-amplitude Jacobian has stale rotation data."
|
||||
);
|
||||
weightedVariation.SetSize(quadraturePointCount);
|
||||
for (int quadraturePoint = 0; quadraturePoint < quadraturePointCount; ++quadraturePoint) {
|
||||
weightedVariation(quadraturePoint) =
|
||||
-2.0 * fractionalAngularVelocityVariation * data.quadratureWeights(quadraturePoint) *
|
||||
data.rotationPotential(quadraturePoint);
|
||||
}
|
||||
elementAction.SetSize(data.enthalpyDofs.Size());
|
||||
data.enthalpyBasis.MultTranspose(weightedVariation, elementAction);
|
||||
if (data.enthalpyDofTransformation != nullptr) {
|
||||
data.enthalpyDofTransformation->TransformDual(elementAction);
|
||||
}
|
||||
localAction.AddElementVector(data.enthalpyDofs, elementAction);
|
||||
}
|
||||
|
||||
local_to_true(*m_fem.enthalpyFes, localAction, m_fullEnthalpyAction);
|
||||
action.SetSize(m_context.GetEnthalpyMap().reduced_size());
|
||||
m_context.GetEnthalpyMap().gather(m_fullEnthalpyAction, action);
|
||||
++m_algebraicJacobianStatistics.rotationAmplitudeApplications;
|
||||
}
|
||||
|
||||
void PreparedHydrostaticEquilibriumOperator::ApplyAlgebraicJacobianAction(
|
||||
const mfem::Vector &enthalpyVariation,
|
||||
const mfem::Vector &gravityPotentialVariation,
|
||||
|
||||
@@ -356,8 +356,11 @@ namespace mean_field::operators {
|
||||
m_rootManifest(
|
||||
constructionData.valueSizes,
|
||||
constructionData.residualSizes,
|
||||
fixedMassConstraint.targetMass().value(),
|
||||
surfaceConstraint.descriptor().targetPressure,
|
||||
StellarEquilibriumSpecificationModel{
|
||||
equationOfState,
|
||||
surface::Isobaric{
|
||||
dimensions::PressureValue{surfaceConstraint.descriptor().targetPressure}},
|
||||
fixedMassConstraint.specification()},
|
||||
constructionData.pressureSurfaceRows.size()
|
||||
),
|
||||
m_gravityStateOffsets(constructionData.gravityStateOffsets),
|
||||
@@ -431,6 +434,7 @@ namespace mean_field::operators {
|
||||
m_fullMechanicalAction.SetSize(m_domainDeformation.volumeDisplacementSize());
|
||||
m_surfaceShapeAction.SetSize(m_domainDeformation.parameterCount());
|
||||
m_pullbackDerivativeAction.SetSize(m_domainDeformation.parameterCount());
|
||||
m_densityVolumeIntegralAction.SetSize(1);
|
||||
|
||||
m_gravityState = 0.0;
|
||||
m_gravityDirection = 0.0;
|
||||
@@ -441,6 +445,7 @@ namespace mean_field::operators {
|
||||
m_fullMechanicalAction = 0.0;
|
||||
m_surfaceShapeAction = 0.0;
|
||||
m_pullbackDerivativeAction = 0.0;
|
||||
m_densityVolumeIntegralAction = 0.0;
|
||||
}
|
||||
|
||||
PreparedStellarEquilibriumReport PreparedStellarEquilibriumOperator::Prepare(
|
||||
@@ -494,13 +499,13 @@ namespace mean_field::operators {
|
||||
|
||||
const auto rootState = m_rootManifest.stateView(state);
|
||||
|
||||
const mfem::Vector reducedDensity = rootState.block(utils::blocks::density_field.mass_term);
|
||||
const mfem::Vector surfaceDeformationParameters =
|
||||
const auto reducedDensity = rootState.block(utils::blocks::density_field.mass_term);
|
||||
const auto surfaceDeformationParameters =
|
||||
rootState.block(utils::blocks::surface_deformation_field.parameters_term);
|
||||
const mfem::Vector gravityGradient = rootState.block(utils::blocks::gravity_field.gradient_term);
|
||||
const mfem::Vector gravityPotential = rootState.block(utils::blocks::gravity_field.poisson_term);
|
||||
const mfem::Vector reducedEnthalpy = rootState.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const mfem::Vector bernoulli =
|
||||
const auto gravityGradient = rootState.block(utils::blocks::gravity_field.gradient_term);
|
||||
const auto gravityPotential = rootState.block(utils::blocks::gravity_field.poisson_term);
|
||||
const auto reducedEnthalpy = rootState.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const auto bernoulli =
|
||||
rootState.block(utils::blocks::fixed_total_mass_constraint.mass_normalization_term);
|
||||
|
||||
const bool generatedGeometryChanged =
|
||||
@@ -633,13 +638,13 @@ namespace mean_field::operators {
|
||||
|
||||
const auto rootDirection = m_rootManifest.directionView(direction);
|
||||
|
||||
const mfem::Vector reducedDensityDirection = rootDirection.block(utils::blocks::density_field.mass_term);
|
||||
const mfem::Vector surfaceDeformationDirection =
|
||||
const auto reducedDensityDirection = rootDirection.block(utils::blocks::density_field.mass_term);
|
||||
const auto surfaceDeformationDirection =
|
||||
rootDirection.block(utils::blocks::surface_deformation_field.parameters_term);
|
||||
const mfem::Vector gravityGradientDirection = rootDirection.block(utils::blocks::gravity_field.gradient_term);
|
||||
const mfem::Vector gravityPotentialDirection = rootDirection.block(utils::blocks::gravity_field.poisson_term);
|
||||
const mfem::Vector reducedEnthalpyDirection = rootDirection.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const mfem::Vector bernoulliDirection =
|
||||
const auto gravityGradientDirection = rootDirection.block(utils::blocks::gravity_field.gradient_term);
|
||||
const auto gravityPotentialDirection = rootDirection.block(utils::blocks::gravity_field.poisson_term);
|
||||
const auto reducedEnthalpyDirection = rootDirection.block(utils::blocks::enthalpy_field.specific_term);
|
||||
const auto bernoulliDirection =
|
||||
rootDirection.block(utils::blocks::fixed_total_mass_constraint.mass_normalization_term);
|
||||
|
||||
m_domainDeformation.applyJacobian(
|
||||
@@ -794,6 +799,41 @@ namespace mean_field::operators {
|
||||
return m_massNormalizationOperator;
|
||||
}
|
||||
|
||||
double PreparedStellarEquilibriumOperator::ApplyDensityVolumeIntegralDensityAction(
|
||||
const mfem::Vector &densityDirection
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
m_massNormalizationOperator.ApplyDensityJacobianAction(
|
||||
densityDirection,
|
||||
m_densityVolumeIntegralAction
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
m_densityVolumeIntegralAction.Size() == 1,
|
||||
"The density-volume integral must produce one global scalar."
|
||||
);
|
||||
return m_densityVolumeIntegralAction(0);
|
||||
}
|
||||
|
||||
double PreparedStellarEquilibriumOperator::ApplyDensityVolumeIntegralSurfaceShapeAction(
|
||||
const mfem::Vector &surfaceShapeDirection
|
||||
) const {
|
||||
VerifyPrepared();
|
||||
m_domainDeformation.applyJacobian(
|
||||
m_surfaceDeformationParameters,
|
||||
surfaceShapeDirection,
|
||||
m_volumeDisplacementDirection
|
||||
);
|
||||
m_massNormalizationOperator.ApplyDisplacementJacobianAction(
|
||||
m_volumeDisplacementDirection,
|
||||
m_densityVolumeIntegralAction
|
||||
);
|
||||
MFEM_VERIFY(
|
||||
m_densityVolumeIntegralAction.Size() == 1,
|
||||
"The density-volume shape derivative must produce one global scalar."
|
||||
);
|
||||
return m_densityVolumeIntegralAction(0);
|
||||
}
|
||||
|
||||
const PreparedPressureSurfaceConstraint &
|
||||
PreparedStellarEquilibriumOperator::GetSurfaceConstraintOperator() const noexcept {
|
||||
return m_surfaceConstraintOperator;
|
||||
|
||||
@@ -3,6 +3,7 @@ module;
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <limits>
|
||||
#include <numbers>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <mfem.hpp>
|
||||
@@ -133,21 +134,15 @@ namespace {
|
||||
|
||||
namespace mean_field::seed::detail {
|
||||
ProjectedRadialFields projectRadialFields(
|
||||
const equilibrium::StellarDiscretization &discretization,
|
||||
fem::FEM &finiteElementModel,
|
||||
const RadialProfile &profile,
|
||||
const dimensions::MassValue targetMass,
|
||||
const dimensions::PressureValue targetSurfacePressure,
|
||||
const StellarEquilibriumProjectionOptions &options
|
||||
) {
|
||||
validate_profile(profile);
|
||||
if (!std::isfinite(options.surfaceRadiusRelativeTolerance) || options.surfaceRadiusRelativeTolerance < 0.0) {
|
||||
throw std::invalid_argument("The surface-radius projection tolerance must be finite and nonnegative.");
|
||||
}
|
||||
if (targetSurfacePressure.value() != 0.0) {
|
||||
throw std::invalid_argument("A Lane-Emden radial seed requires a zero-pressure isobaric surface.");
|
||||
}
|
||||
|
||||
fem::FEM &finiteElementModel = discretization.finiteElementModel();
|
||||
const SurfaceRadiusRange surfaceRadius = measure_surface_radius(finiteElementModel);
|
||||
const double targetRadius = profile.stellarRadius.value();
|
||||
const double comparisonScale = std::max({targetRadius, surfaceRadius.maximum, 1.0e-300});
|
||||
@@ -185,6 +180,20 @@ namespace mean_field::seed::detail {
|
||||
const physics::GravitySolution gravitySolution =
|
||||
physics::solve_gravity_field(finiteElementModel, options.gravity, densityField, displacementField);
|
||||
|
||||
double radialMomentIntegral = 0.0;
|
||||
for (int index = 0; index + 1 < profile.radius.Size(); ++index) {
|
||||
const double leftRadius = profile.radius(index);
|
||||
const double rightRadius = profile.radius(index + 1);
|
||||
const double leftIntegrand = profile.density(index) * std::pow(leftRadius, 4);
|
||||
const double rightIntegrand = profile.density(index + 1) * std::pow(rightRadius, 4);
|
||||
radialMomentIntegral +=
|
||||
0.5 * (rightRadius - leftRadius) * (leftIntegrand + rightIntegrand);
|
||||
}
|
||||
const double sphericalMomentOfInertia = (8.0 * std::numbers::pi / 3.0) * radialMomentIntegral;
|
||||
if (!std::isfinite(sphericalMomentOfInertia) || sphericalMomentOfInertia <= 0.0) {
|
||||
throw std::runtime_error("The radial profile has no finite, positive moment of inertia.");
|
||||
}
|
||||
|
||||
const field::FieldDofGridFunctionAdapter densityAdapter =
|
||||
field::make_field_dof_grid_function_adapter<field::Density, DomainSchema>(*finiteElementModel.densityFes);
|
||||
const field::FieldDofGridFunctionAdapter enthalpyAdapter =
|
||||
@@ -203,7 +212,8 @@ namespace mean_field::seed::detail {
|
||||
.gravityGradient = gravityFluxAdapter.gather(gravitySolution.gradPhi),
|
||||
.gravityPotential = gravityPotentialAdapter.gather(gravitySolution.phi),
|
||||
.specificEnthalpy = enthalpyAdapter.gather(enthalpyField),
|
||||
.bernoulliConstant = -utils::G * targetMass.value() / targetRadius
|
||||
.bernoulliConstant = -utils::G * targetMass.value() / targetRadius,
|
||||
.sphericalMomentOfInertia = sphericalMomentOfInertia
|
||||
};
|
||||
}
|
||||
} // namespace mean_field::seed::detail
|
||||
|
||||
Reference in New Issue
Block a user