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

feat(support): continued migration to new field dof support system

Browse Source 
mass normaliztion, gravity, displacement, and hydrostatic equilibrium are now migrated
This commit is contained in:
Emily Boudreaux
2026-08-24 15:44:24 -04:00
parent 0f3ca8050b
commit 177ae8b38a
48 changed files with 1738 additions and 935 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
libmeanfield/impl/operators/gravity_field.cpp
View File

@@ -12,18 +12,16 @@ import :operators.kernels.gravity_field;
namespace {
using namespace mean_field;
int get_state_width(const mfem::Array<int> &state_true_offsets) {
MFEM_VERIFY(state_true_offsets.Size() >= 2, "The coupled state requires at least one block.");
MFEM_VERIFY(state_true_offsets[0] == 0, "The coupled state offsets must begin at zero.");
int get_state_width(const mfem::Array<int> &state_offsets) {
MFEM_VERIFY(state_offsets.Size() >= 2, "The coupled state requires at least one block.");
MFEM_VERIFY(state_offsets[0] == 0, "The coupled state offsets must begin at zero.");
for (int i = 0; i < state_true_offsets.Size() - 1; ++i) {
MFEM_VERIFY(
state_true_offsets[i + 1] >= state_true_offsets[i], "The coupled state offsets must be nondecreasing."
);
for (int i = 0; i < state_offsets.Size() - 1; ++i) {
MFEM_VERIFY(state_offsets[i + 1] >= state_offsets[i], "The coupled state offsets must be nondecreasing.");
}
MFEM_VERIFY(state_true_offsets.Last() > 0, "The coupled state cannot be empty.");
return state_true_offsets.Last();
MFEM_VERIFY(state_offsets.Last() > 0, "The coupled state cannot be empty.");
return state_offsets.Last();
}
int get_gravity_residual_height(const fem::FEM &f) {
@@ -37,29 +35,33 @@ namespace {
"space (L2: Lebesgue "
"space of square-integrable functions)."
);
return f.gravityFluxFes->GetTrueVSize() + f.gravityPotentialFes->GetTrueVSize();
using DomainSchema = utils::domain::CoreEnvelopeVacuumDomainSchema;
return field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityFluxFes).reduced_size() +
field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityPotentialFes).reduced_size();
}
mfem::Array<int> make_gravity_residual_offsets(const fem::FEM &f) {
mfem::Array<int> offsets(operators::gravity_residual_block_count + 1);
offsets[0] = 0;
offsets[1] = f.gravityFluxFes->GetTrueVSize();
offsets[2] = offsets[1] + f.gravityPotentialFes->GetTrueVSize();
mfem::Array<int> offsets(utils::blocks::gravity_field_form::residual_block_count + 1);
offsets[0] = 0;
using DomainSchema = utils::domain::CoreEnvelopeVacuumDomainSchema;
offsets[1] = field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityFluxFes).reduced_size();
offsets[2] =
offsets[1] + field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityPotentialFes).reduced_size();
return offsets;
}
template <int index>
int get_state_block_size(
const mfem::Array<int> &state_true_offsets,
const mfem::Array<int> &state_offsets,
const utils::blocks::value_block<index>
) {
MFEM_VERIFY(index + 1 < state_true_offsets.Size(), "Value block is not present in the state offsets.");
return state_true_offsets[index + 1] - state_true_offsets[index];
MFEM_VERIFY(index + 1 < state_offsets.Size(), "Value block is not present in the state offsets.");
return state_offsets[index + 1] - state_offsets[index];
}
void validate_state_offsets(
const fem::FEM &f,
const mfem::Array<int> &state_true_offsets
const mfem::Array<int> &state_offsets
) {
MFEM_VERIFY(f.densityFes != nullptr, "GravityFieldOperator requires the density finite-element space.");
MFEM_VERIFY(
@@ -78,26 +80,32 @@ namespace {
utils::blocks::get_value_block<form>(utils::blocks::gravity_field.poisson_term);
MFEM_VERIFY(
state_true_offsets.Size() == form::value_block_count + 1,
state_offsets.Size() == form::value_block_count + 1,
"The gravity state offsets do not match gravity_field_form."
);
using DomainSchema = utils::domain::CoreEnvelopeVacuumDomainSchema;
const auto density_map = field::make_field_dof_map<field::Density, DomainSchema>(*f.densityFes);
const auto displacement_map = field::make_field_dof_map<field::Displacement, DomainSchema>(*f.displacementFes);
const auto flux_map = field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityFluxFes);
const auto potential_map = field::make_field_dof_map<field::Gravity, DomainSchema>(*f.gravityPotentialFes);
MFEM_VERIFY(
get_state_block_size(state_true_offsets, density_block) == f.densityFes->GetTrueVSize(),
get_state_block_size(state_offsets, density_block) == density_map.reduced_size(),
"The density block does not match the density finite-element space."
);
MFEM_VERIFY(
get_state_block_size(state_true_offsets, displacement_block) == f.displacementFes->GetTrueVSize(),
get_state_block_size(state_offsets, displacement_block) == displacement_map.reduced_size(),
"The displacement block does not match the displacement "
"finite-element "
"space."
);
MFEM_VERIFY(
get_state_block_size(state_true_offsets, gravity_gradient_block) == f.gravityFluxFes->GetTrueVSize(),
get_state_block_size(state_offsets, gravity_gradient_block) == flux_map.reduced_size(),
"The gravity-gradient block does not match the RT finite-element "
"space."
);
MFEM_VERIFY(
get_state_block_size(state_true_offsets, gravity_potential_block) == f.gravityPotentialFes->GetTrueVSize(),
get_state_block_size(state_offsets, gravity_potential_block) == potential_map.reduced_size(),
"The gravity-potential block does not match the potential "
"finite-element space."
);
@@ -162,18 +170,18 @@ namespace mean_field::operators {
fem::FEM &f,
const mapping::DomainMapperStateless &domain_mapper,
context::gravity_field::GravityFieldLinearizationContext &linearization_context,
const mfem::Array<int> &state_true_offsets,
const mfem::Array<int> &state_offsets,
GravityFieldJacobianOperator &jacobian
)
: Operator(
get_gravity_residual_height(f),
get_state_width(state_true_offsets)
get_state_width(state_offsets)
),
m_fem(f),
m_domain_mapper(domain_mapper),
m_linearization_context(linearization_context),
m_state_true_offsets(state_true_offsets),
m_residual_true_offsets(make_gravity_residual_offsets(f)),
m_state_offsets(state_offsets),
m_residual_offsets(make_gravity_residual_offsets(f)),
m_jacobian(jacobian) {
MFEM_VERIFY(f.mesh != nullptr, "GravityFieldOperator requires a mesh.");
MFEM_VERIFY(
@@ -198,7 +206,7 @@ namespace mean_field::operators {
"dimension."
);
validate_state_offsets(f, m_state_true_offsets);
validate_state_offsets(f, m_state_offsets);
validate_gravity_context(f);
bool has_vacuum_domain = false;
@@ -212,11 +220,9 @@ namespace mean_field::operators {
MFEM_VERIFY(has_vacuum_domain, "GravityFieldOperator requires a compactified vacuum domain.");
MFEM_VERIFY(
m_residual_true_offsets.Last() == Height(), "The gravity residual offsets do not match the operator height."
);
MFEM_VERIFY(
m_state_true_offsets.Last() == Width(), "The coupled state offsets do not match the operator width."
m_residual_offsets.Last() == Height(), "The gravity residual offsets do not match the operator height."
);
MFEM_VERIFY(m_state_offsets.Last() == Width(), "The coupled state offsets do not match the operator width.");
}
context::gravity_field::GravityFieldPreparationReport GravityFieldOperator::Prepare(
@@ -238,12 +244,11 @@ namespace mean_field::operators {
"preparation state with the wrong size."
);
const mfem::Vector density = make_read_only_value_view(state, m_state_true_offsets, density_block);
const mfem::Vector displacement = make_read_only_value_view(state, m_state_true_offsets, displacement_block);
const mfem::Vector gravity_gradient =
make_read_only_value_view(state, m_state_true_offsets, gravity_gradient_block);
const mfem::Vector density = make_read_only_value_view(state, m_state_offsets, density_block);
const mfem::Vector displacement = make_read_only_value_view(state, m_state_offsets, displacement_block);
const mfem::Vector gravity_gradient = make_read_only_value_view(state, m_state_offsets, gravity_gradient_block);
const mfem::Vector gravity_potential =
make_read_only_value_view(state, m_state_true_offsets, gravity_potential_block);
make_read_only_value_view(state, m_state_offsets, gravity_potential_block);
return m_linearization_context.Prepare(
{.density = density,
@@ -254,12 +259,12 @@ namespace mean_field::operators {
);
}
const mfem::Array<int> &GravityFieldOperator::GetStateTrueOffsets() const noexcept {
return m_state_true_offsets;
const mfem::Array<int> &GravityFieldOperator::GetStateOffsets() const noexcept {
return m_state_offsets;
}
const mfem::Array<int> &GravityFieldOperator::GetResidualTrueOffsets() const noexcept {
return m_residual_true_offsets;
const mfem::Array<int> &GravityFieldOperator::GetResidualOffsets() const noexcept {
return m_residual_offsets;
}
void GravityFieldOperator::ApplyGravityUnknowns(
@@ -277,12 +282,12 @@ namespace mean_field::operators {
MFEM_VERIFY(geometry_context.IsPrepared(), "GravityFieldOperator received an unprepared geometry context.");
MFEM_VERIFY(
gravity_gradient.Size() == m_fem.gravityFluxFes->GetTrueVSize(),
gravity_gradient.Size() == geometry_context.GetMassOperator().GetFluxMap().reduced_size(),
"GravityFieldOperator received a gravity-gradient vector with the "
"wrong size."
);
MFEM_VERIFY(
gravity_potential.Size() == m_fem.gravityPotentialFes->GetTrueVSize(),
gravity_potential.Size() == geometry_context.GetSourceOperator().GetPotentialMap().reduced_size(),
"GravityFieldOperator received a gravity-potential vector with the "
"wrong size."
);
@@ -291,15 +296,25 @@ namespace mean_field::operators {
action = 0.0;
mfem::Vector gravity_gradient_action =
make_residual_view(action, m_residual_true_offsets, gravity_gradient_residual_block);
make_residual_view(action, m_residual_offsets, gravity_gradient_residual_block);
mfem::Vector gravity_poisson_action =
make_residual_view(action, m_residual_true_offsets, gravity_poisson_residual_block);
mfem::Vector transpose_divergence_action(gravity_gradient_action.Size());
make_residual_view(action, m_residual_offsets, gravity_poisson_residual_block);
const field::FieldDofMap &flux_map = geometry_context.GetMassOperator().GetFluxMap();
const field::FieldDofMap &potential_map = geometry_context.GetSourceOperator().GetPotentialMap();
mfem::Vector potential_true(potential_map.full_size());
mfem::Vector transpose_divergence_action_true(flux_map.full_size());
mfem::Vector transpose_divergence_action(flux_map.reduced_size());
mfem::Vector gradient_true(flux_map.full_size());
mfem::Vector divergence_action_true(potential_map.full_size());
geometry_context.GetMassOperator().Mult(gravity_gradient, gravity_gradient_action);
m_fem.gravityContext.BT->Mult(gravity_potential, transpose_divergence_action);
potential_map.scatter(gravity_potential, potential_true);
m_fem.gravityContext.BT->Mult(potential_true, transpose_divergence_action_true);
flux_map.gather(transpose_divergence_action_true, transpose_divergence_action);
gravity_gradient_action += transpose_divergence_action;
m_fem.gravityContext.b_form->Mult(gravity_gradient, gravity_poisson_action);
flux_map.scatter(gravity_gradient, gradient_true);
m_fem.gravityContext.b_form->Mult(gradient_true, divergence_action_true);
potential_map.gather(divergence_action_true, gravity_poisson_action);
}
void GravityFieldOperator::ApplyDensitySource(
@@ -314,7 +329,7 @@ namespace mean_field::operators {
MFEM_VERIFY(geometry_context.IsPrepared(), "GravityFieldOperator received an unprepared geometry context.");
MFEM_VERIFY(
density.Size() == m_fem.densityFes->GetTrueVSize(),
density.Size() == geometry_context.GetSourceOperator().GetDensityMap().reduced_size(),
"GravityFieldOperator received a density vector with the wrong "
"size."
);
@@ -323,7 +338,7 @@ namespace mean_field::operators {
action = 0.0;
mfem::Vector gravity_poisson_action =
make_residual_view(action, m_residual_true_offsets, gravity_poisson_residual_block);
make_residual_view(action, m_residual_offsets, gravity_poisson_residual_block);
geometry_context.GetSourceOperator().Mult(density, gravity_poisson_action);
}
@@ -346,11 +361,10 @@ namespace mean_field::operators {
m_linearization_context.IsPrepared(), "GravityFieldOperator must be prepared before Mult is called."
);
const mfem::Vector density = make_read_only_value_view(state, m_state_true_offsets, density_block);
const mfem::Vector gravity_gradient =
make_read_only_value_view(state, m_state_true_offsets, gravity_gradient_block);
const mfem::Vector density = make_read_only_value_view(state, m_state_offsets, density_block);
const mfem::Vector gravity_gradient = make_read_only_value_view(state, m_state_offsets, gravity_gradient_block);
const mfem::Vector gravity_potential =
make_read_only_value_view(state, m_state_true_offsets, gravity_potential_block);
make_read_only_value_view(state, m_state_offsets, gravity_potential_block);
const context::gravity_field::GravityFieldGeometryContext &geometry_context =
m_linearization_context.GetGeometryContext();
@@ -393,7 +407,7 @@ namespace mean_field::operators {
gravity_field_operator.Height()
),
m_gravity_field_operator(gravity_field_operator),
m_gravity_true_offsets(gravity_field_operator.GetResidualTrueOffsets()),
m_gravity_offsets(gravity_field_operator.GetResidualOffsets()),
m_gravity_field_geometry_context(gravity_field_geometry_context) {
using form = utils::blocks::gravity_field_form;
@@ -406,52 +420,48 @@ namespace mean_field::operators {
constexpr auto gravity_poisson_residual_block =
utils::blocks::get_residual_block<form>(utils::blocks::gravity_field.poisson_term);
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateTrueOffsets();
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateOffsets();
MFEM_VERIFY(
state_offsets.Size() == form::value_block_count + 1,
"ReducedGravityFieldOperator received an invalid full-state layout."
"ReducedGravityFieldOperator received an invalid coupled-state layout."
);
MFEM_VERIFY(
m_gravity_true_offsets.Size() == form::residual_block_count + 1,
m_gravity_offsets.Size() == form::residual_block_count + 1,
"ReducedGravityFieldOperator received an invalid gravity-residual "
"layout."
);
MFEM_VERIFY(state_offsets[0] == 0, "The full-state offsets must begin at zero.");
MFEM_VERIFY(m_gravity_true_offsets[0] == 0, "The reduced gravity offsets must begin at zero.");
MFEM_VERIFY(state_offsets[0] == 0, "The coupled-state offsets must begin at zero.");
MFEM_VERIFY(m_gravity_offsets[0] == 0, "The reduced gravity offsets must begin at zero.");
MFEM_VERIFY(
state_offsets.Last() == m_gravity_field_operator.Width(),
"The full-state offsets do not match the gravity-field operator "
"The coupled-state offsets do not match the gravity-field operator "
"width."
);
MFEM_VERIFY(
m_gravity_true_offsets.Last() == m_gravity_field_operator.Height(),
m_gravity_offsets.Last() == m_gravity_field_operator.Height(),
"The reduced gravity offsets do not match the gravity-field "
"operator "
"height."
);
MFEM_VERIFY(Width() == Height(), "ReducedGravityFieldOperator must be square.");
const int full_gradient_size =
const int state_gradient_size =
state_offsets[static_cast<int>(gravity_gradient_block) + 1] - state_offsets[gravity_gradient_block];
const int full_potential_size =
const int state_potential_size =
state_offsets[static_cast<int>(gravity_potential_block) + 1] - state_offsets[gravity_potential_block];
const int reduced_gradient_size =
m_gravity_true_offsets[static_cast<int>(gravity_gradient_residual_block) + 1] -
m_gravity_true_offsets[gravity_gradient_residual_block];
const int reduced_potential_size =
m_gravity_true_offsets[static_cast<int>(gravity_poisson_residual_block) + 1] -
m_gravity_true_offsets[gravity_poisson_residual_block];
const int gravity_gradient_size = m_gravity_offsets[static_cast<int>(gravity_gradient_residual_block) + 1] -
m_gravity_offsets[gravity_gradient_residual_block];
const int gravity_potential_size = m_gravity_offsets[static_cast<int>(gravity_poisson_residual_block) + 1] -
m_gravity_offsets[gravity_poisson_residual_block];
MFEM_VERIFY(
full_gradient_size == reduced_gradient_size,
"The reduced gravity-gradient block does not match the full-state "
"gravity-gradient block."
state_gradient_size == gravity_gradient_size, "The gravity-gradient block does not match the coupled-state "
"gravity-gradient block."
);
MFEM_VERIFY(
full_potential_size == reduced_potential_size,
"The reduced gravity-potential block does not match the Poisson "
"residual block."
state_potential_size == gravity_potential_size, "The gravity-potential block does not match the Poisson "
"residual block."
);
SetDisplacement(displacement);
@@ -475,10 +485,11 @@ namespace mean_field::operators {
}
m_gravity_field_geometry_context.Prepare(displacement, discretization_revision, displacement_revision);
m_displacement = displacement;
}
const mfem::Vector &ReducedGravityFieldOperator::GetDisplacement() const {
return m_gravity_field_geometry_context.GetDisplacement();
return m_displacement;
}
void ReducedGravityFieldOperator::BuildRightHandSide(
@@ -511,13 +522,13 @@ namespace mean_field::operators {
ValidateGravityState(gravity_state);
const mfem::Vector gravity_gradient_true =
make_read_only_residual_view(gravity_state, m_gravity_true_offsets, gravity_gradient_residual_block);
const mfem::Vector gravity_potential_true =
make_read_only_residual_view(gravity_state, m_gravity_true_offsets, gravity_poisson_residual_block);
const mfem::Vector gravity_gradient =
make_read_only_residual_view(gravity_state, m_gravity_offsets, gravity_gradient_residual_block);
const mfem::Vector gravity_potential =
make_read_only_residual_view(gravity_state, m_gravity_offsets, gravity_poisson_residual_block);
m_gravity_field_operator.ApplyGravityUnknowns(
gravity_gradient_true, gravity_potential_true, m_gravity_field_geometry_context, action
gravity_gradient, gravity_potential, m_gravity_field_geometry_context, action
);
MFEM_VERIFY(
@@ -543,8 +554,8 @@ namespace mean_field::operators {
return m_gravity_field_geometry_context;
}
const mfem::Array<int> &ReducedGravityFieldOperator::GetGravityTrueOffsets() const noexcept {
return m_gravity_true_offsets;
const mfem::Array<int> &ReducedGravityFieldOperator::GetGravityOffsets() const noexcept {
return m_gravity_offsets;
}
void ReducedGravityFieldOperator::ValidateDisplacement(const mfem::Vector &displacement) const {
@@ -553,7 +564,7 @@ namespace mean_field::operators {
constexpr auto displacement_block =
utils::blocks::get_value_block<form>(utils::blocks::displacement_field.geometry_term);
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateTrueOffsets();
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateOffsets();
const int expected_size =
state_offsets[static_cast<int>(displacement_block) + 1] - state_offsets[displacement_block];
@@ -577,7 +588,7 @@ namespace mean_field::operators {
constexpr auto density_block = utils::blocks::get_value_block<form>(utils::blocks::density_field.mass_term);
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateTrueOffsets();
const mfem::Array<int> &state_offsets = m_gravity_field_operator.GetStateOffsets();
const int expected_size = state_offsets[static_cast<int>(density_block) + 1] - state_offsets[density_block];
MFEM_VERIFY(