Emily Boudreaux
85500fef3b
restricted the unknown state vector to surface deformation and implemented one prescription, NodalRadialSurface, while the full volumetric displacment field is reconstructed analytically from that. This reduced the number of degrees of freedom in the system by a factor of 80 while also removing many null vectors from the system.
372 lines
16 KiB
C++
372 lines
16 KiB
C++
module;
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <expected>
|
|
#include <limits>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
#include <mfem.hpp>
|
|
#include <stroid/stroid.h>
|
|
|
|
module mean_field;
|
|
|
|
import :boundary.contexts;
|
|
import :field.mfem;
|
|
import :mapping.coefficients;
|
|
import :utils.misc;
|
|
import :utils.user;
|
|
|
|
namespace mean_field::fem {
|
|
FEM setup_fem(
|
|
const std::string &filename,
|
|
const utils::Args &args,
|
|
const int extraRefine
|
|
) {
|
|
FEM fem;
|
|
|
|
using GravityPotential = field::Gravity::Potential;
|
|
using GravityFlux = field::Gravity::Flux;
|
|
using DisplacementVector = field::Displacement::Vector;
|
|
using DensityScalar = field::Density::Scalar;
|
|
using EnthalpyScalar = field::Enthalpy::Scalar;
|
|
using DomainSchema = utils::domain::CoreEnvelopeVacuumDomainSchema;
|
|
|
|
// =====================================================================
|
|
// Section 1: Mesh construction
|
|
// =====================================================================
|
|
|
|
fem.smesh = stroid::IO::LoadStroidMesh(filename).value();
|
|
|
|
if (extraRefine > 0) {
|
|
stroid::refinement::UniformRefinement(fem.smesh, extraRefine);
|
|
}
|
|
|
|
if (fem.smesh.mesh == nullptr || fem.smesh.reference_mesh == nullptr) {
|
|
throw std::runtime_error("A STROID mesh requires paired physical and logical reference meshes.");
|
|
}
|
|
|
|
int mpiSize = 1;
|
|
MPI_Comm_size(MPI_COMM_WORLD, &mpiSize);
|
|
|
|
const std::unique_ptr<int[]> meshPartitioning(fem.smesh.mesh->GeneratePartitioning(mpiSize, 1));
|
|
|
|
fem.mesh = std::make_unique<mfem::ParMesh>(MPI_COMM_WORLD, *fem.smesh.mesh, meshPartitioning.get(), 1);
|
|
fem.logicalReferenceMesh =
|
|
std::make_unique<mfem::ParMesh>(MPI_COMM_WORLD, *fem.smesh.reference_mesh, meshPartitioning.get(), 1);
|
|
|
|
fem.mesh->EnsureNodes();
|
|
|
|
if (fem.logicalReferenceMesh->GetNE() != fem.mesh->GetNE()) {
|
|
throw std::runtime_error("The physical and logical reference meshes have incompatible local elements.");
|
|
}
|
|
for (int element = 0; element < fem.mesh->GetNE(); ++element) {
|
|
if (fem.logicalReferenceMesh->GetElementGeometry(element) != fem.mesh->GetElementGeometry(element) ||
|
|
fem.logicalReferenceMesh->GetAttribute(element) != fem.mesh->GetAttribute(element)) {
|
|
throw std::runtime_error(
|
|
"The physical and logical reference meshes do not preserve element correspondence."
|
|
);
|
|
}
|
|
}
|
|
|
|
// =====================================================================
|
|
// Section 2: Exterior compactification coordinate
|
|
// =====================================================================
|
|
|
|
if (fem.smesh.exterior_coordinate == nullptr) {
|
|
throw std::runtime_error("Exterior coordinate not set.");
|
|
}
|
|
|
|
if (fem.smesh.exterior_coordinate->space == nullptr) {
|
|
throw std::runtime_error("Space for exterior coordinate not set.");
|
|
}
|
|
|
|
if (fem.smesh.exterior_coordinate->values == nullptr) {
|
|
throw std::runtime_error("Values for exterior coordinate not set.");
|
|
}
|
|
|
|
const mfem::FiniteElementSpace &serialCoordinateSpace = *fem.smesh.exterior_coordinate->space;
|
|
|
|
const mfem::GridFunction &serialCoordinate = *fem.smesh.exterior_coordinate->values;
|
|
|
|
if (serialCoordinate.FESpace() != &serialCoordinateSpace) {
|
|
throw std::runtime_error(
|
|
"Exterior coordinate values are not associated with the "
|
|
"supplied finite-element space."
|
|
);
|
|
}
|
|
|
|
if (serialCoordinateSpace.GetMesh() != fem.smesh.mesh.get()) {
|
|
throw std::runtime_error(
|
|
"Exterior coordinate space is not associated with the "
|
|
"loaded STROID mesh."
|
|
);
|
|
}
|
|
|
|
if (serialCoordinateSpace.GetVDim() != 1) {
|
|
throw std::runtime_error("Exterior coordinate must be a scalar field.");
|
|
}
|
|
|
|
if (serialCoordinate.Size() != serialCoordinateSpace.GetVSize()) {
|
|
throw std::runtime_error(
|
|
"Exterior coordinate value count does not match its "
|
|
"finite-element space."
|
|
);
|
|
}
|
|
|
|
const int compactificationOrder = serialCoordinateSpace.GetMaxElementOrder();
|
|
|
|
const int dimension = fem.mesh->Dimension();
|
|
|
|
fem.compactificationFec = std::make_unique<mfem::H1_FECollection>(compactificationOrder, dimension);
|
|
|
|
fem.compactificationFes =
|
|
std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.compactificationFec.get());
|
|
|
|
mfem::ParGridFunction distributedCoordinate(fem.mesh.get(), &serialCoordinate, meshPartitioning.get());
|
|
|
|
if (distributedCoordinate.Size() != fem.compactificationFes->GetVSize()) {
|
|
throw std::runtime_error(
|
|
"Distributed exterior coordinate does not match the "
|
|
"constructed parallel finite-element space."
|
|
);
|
|
}
|
|
|
|
fem.compactificationCoordinate = std::make_unique<mfem::ParGridFunction>(fem.compactificationFes.get());
|
|
|
|
*fem.compactificationCoordinate = distributedCoordinate;
|
|
|
|
double localMinimum = std::numeric_limits<double>::infinity();
|
|
|
|
double localMaximum = -std::numeric_limits<double>::infinity();
|
|
|
|
for (int index = 0; index < fem.compactificationCoordinate->Size(); ++index) {
|
|
const double value = (*fem.compactificationCoordinate)(index);
|
|
|
|
if (!std::isfinite(value)) {
|
|
throw std::runtime_error("Exterior coordinate contains a non-finite value.");
|
|
}
|
|
|
|
localMinimum = std::min(localMinimum, value);
|
|
|
|
localMaximum = std::max(localMaximum, value);
|
|
}
|
|
|
|
double globalMinimum = 0.0;
|
|
double globalMaximum = 0.0;
|
|
|
|
MPI_Allreduce(&localMinimum, &globalMinimum, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
|
|
|
|
MPI_Allreduce(&localMaximum, &globalMaximum, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
|
|
|
|
constexpr double coordinateTolerance = 1.0e-12;
|
|
|
|
if (globalMinimum < -coordinateTolerance || globalMaximum > 1.0 + coordinateTolerance) {
|
|
throw std::runtime_error(
|
|
"Exterior coordinate lies outside the expected "
|
|
"interval [0, 1]."
|
|
);
|
|
}
|
|
|
|
// =====================================================================
|
|
// Section 3: Compile-time field realization
|
|
// =====================================================================
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Gravity potential: scalar L2
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.gravityPotentialFec = GravityField::make_fec<GravityPotential>(dimension);
|
|
|
|
fem.gravityPotentialFes = GravityField::make_fespace<GravityPotential>(*fem.mesh, *fem.gravityPotentialFec);
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Gravity flux: H(div)/RT. Basis choices are encoded by field.mfem.
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.gravityFluxFec = GravityField::make_fec<GravityFlux>(dimension);
|
|
|
|
fem.gravityFluxFes = GravityField::make_fespace<GravityFlux>(*fem.mesh, *fem.gravityFluxFec);
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Displacement: vector H1. Ordering is encoded by field.mfem.
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.displacementFec = DisplacementField::make_fec<DisplacementVector>(dimension);
|
|
|
|
fem.displacementFes = DisplacementField::make_fespace<DisplacementVector>(*fem.mesh, *fem.displacementFec);
|
|
|
|
fem.displacement = std::make_unique<mfem::ParGridFunction>(fem.displacementFes.get());
|
|
|
|
*fem.displacement = 0.0;
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Surface deformation: scalar H1 coordinates on StellarSurface.
|
|
//
|
|
// This ambient scalar space exists only to define the surface basis
|
|
// and owned true-DOF topology. Interior scalar DOFs are not nonlinear
|
|
// unknowns.
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.surfaceDeformationFes =
|
|
std::make_unique<mfem::ParFiniteElementSpace>(fem.mesh.get(), fem.displacementFec.get());
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Density: scalar discontinuous L2
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.densityFec = DensityField::make_fec<DensityScalar>(dimension);
|
|
|
|
fem.densityFes = DensityField::make_fespace<DensityScalar>(*fem.mesh, *fem.densityFec);
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Specific enthalpy: scalar continuous H1
|
|
// ---------------------------------------------------------------------
|
|
|
|
fem.enthalpyFec = EnthalpyField::make_fec<EnthalpyScalar>(dimension);
|
|
|
|
fem.enthalpyFes = EnthalpyField::make_fespace<EnthalpyScalar>(*fem.mesh, *fem.enthalpyFec);
|
|
|
|
// =====================================================================
|
|
// Section 4: Multipole data
|
|
// =====================================================================
|
|
|
|
fem.com.SetSize(dimension);
|
|
fem.com = 0.0;
|
|
|
|
fem.Q.SetSize(dimension, dimension);
|
|
fem.Q = 0.0;
|
|
|
|
// =====================================================================
|
|
// Section 5: Boundary markers
|
|
// =====================================================================
|
|
|
|
const int boundaryAttributeCount = fem.mesh->bdr_attributes.Max();
|
|
|
|
fem.boundaryContext.inf_bounds.SetSize(boundaryAttributeCount);
|
|
|
|
fem.boundaryContext.stellar_bounds.SetSize(boundaryAttributeCount);
|
|
|
|
fem.boundaryContext.inf_bounds = 0;
|
|
fem.boundaryContext.stellar_bounds = 0;
|
|
|
|
fem.boundaryContext.inf_bounds[static_cast<int>(boundary::Boundaries::INF_SURFACE) - 1] = 1;
|
|
|
|
fem.boundaryContext.stellar_bounds[static_cast<int>(boundary::Boundaries::STELLAR_SURFACE) - 1] = 1;
|
|
|
|
// =====================================================================
|
|
// Section 7: Quadrature policy
|
|
// =====================================================================
|
|
|
|
const quadrature::QuadratureOptions &quadratureOptions = args.quadrature;
|
|
|
|
if (quadratureOptions.validation.reject_negative_boosts && quadratureOptions.global_boost < 0) {
|
|
throw std::invalid_argument("Global quadrature boost cannot be negative.");
|
|
}
|
|
|
|
quadrature::RuleSet quadratureRuleSet =
|
|
quadrature::make_rule_set(quadratureOptions.mode, quadratureOptions.global_boost);
|
|
|
|
if (quadratureOptions.fallback_fixed_order.has_value()) {
|
|
if (*quadratureOptions.fallback_fixed_order < 0) {
|
|
throw std::invalid_argument("Fallback quadrature order cannot be negative.");
|
|
}
|
|
|
|
quadratureRuleSet.fallback.fixed_order = quadratureOptions.fallback_fixed_order;
|
|
}
|
|
|
|
auto apply_quadrature_options = [&quadratureOptions](
|
|
quadrature::RuleControl &ruleControl,
|
|
const quadrature::QuadratureTermOptions &termOptions
|
|
) {
|
|
if (termOptions.fixed_order.has_value() && *termOptions.fixed_order < 0) {
|
|
throw std::invalid_argument("Fixed quadrature order cannot be negative.");
|
|
}
|
|
|
|
if (quadratureOptions.validation.reject_negative_boosts && termOptions.additional_boost < 0) {
|
|
throw std::invalid_argument("Term quadrature boost cannot be negative.");
|
|
}
|
|
|
|
ruleControl.boost += termOptions.additional_boost;
|
|
|
|
if (termOptions.fixed_order.has_value()) {
|
|
ruleControl.fixed_order = termOptions.fixed_order;
|
|
}
|
|
};
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravity_hdiv_mass, quadratureOptions.gravity_hdiv_mass);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravity_divergence, quadratureOptions.gravity_divergence);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravity_source, quadratureOptions.gravity_source);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravity_force, quadratureOptions.gravity_force);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravity_boundary, quadratureOptions.gravity_boundary);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.centrifugal, quadratureOptions.centrifugal);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.density_projection, quadratureOptions.density_projection);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.eos_closure, quadratureOptions.eos_closure);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.hydrostatic_equilibrium, quadratureOptions.hydrostatic_equilibrium);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.isobaric_surface, quadratureOptions.isobaric_surface);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.mesh_extension, quadratureOptions.mesh_extension);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.mass_conservation, quadratureOptions.mass_conservation);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.mass_normalization, quadratureOptions.mass_normalization);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.center_of_mass, quadratureOptions.center_of_mass);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.quadrupole, quadratureOptions.quadrupole);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.gravitational_energy, quadratureOptions.gravitational_energy);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.pressure_integral, quadratureOptions.pressure_integral);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.pressure_force, quadratureOptions.pressure_force);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.virial, quadratureOptions.virial);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.error_norm, quadratureOptions.error_norm);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.roles.discretization, quadratureOptions.roles.discretization);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.roles.preconditioner, quadratureOptions.roles.preconditioner);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.roles.diagnostic, quadratureOptions.roles.diagnostic);
|
|
|
|
apply_quadrature_options(quadratureRuleSet.roles.projection, quadratureOptions.roles.projection);
|
|
|
|
fem.quadratureFactory =
|
|
std::make_unique<quadrature::RuleFactory>(quadrature::Policy(std::move(quadratureRuleSet)));
|
|
|
|
// =====================================================================
|
|
// Section 11: Stateless domain mapper
|
|
// =====================================================================
|
|
|
|
auto exteriorDomain =
|
|
std::make_unique<const mapping::compactification::KelvinCompactification>(args.kelvin_options);
|
|
|
|
MFEM_VERIFY(
|
|
args.domain_mapper_options.vacuum_element_attribute ==
|
|
DomainSchema::template material_attribute<utils::domain::Vacuum>(),
|
|
"The domain-mapper compactification attribute must match the vacuum "
|
|
"material registered by the "
|
|
"production domain schema."
|
|
);
|
|
|
|
fem.domainMapperStateless =
|
|
std::make_unique<mapping::DomainMapper>(args.domain_mapper_options, std::move(exteriorDomain));
|
|
|
|
return fem;
|
|
}
|
|
} // namespace mean_field::fem
|