baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
12d51480ded95d070f7db45d7ca6e8b0a2d68c77
FESADev/tests/unit/analysis/hht_shell_physics_test.cpp
T

3667 lines
176 KiB
C++
Raw Blame History

#include <gtest/gtest.h>
#include <algorithm>
#include <array>
#include <cfenv>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <initializer_list>
#include <iostream>
#include <limits>
#include <memory>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include "analysis/hht_dynamic_internal.h"
#include "analysis/hht_reduced_internal.h"
#include "analysis/hht_reduced_increment.h"
#include "analysis/hht_reduced_procedure.h"
#include "fesa/analysis/analysis_model.h"
#include "fesa/analysis/newton_iteration_log.h"
#include "fesa/assembly/parallel_for.h"
#include "fesa/elements/finite_rotation.h"
#include "fesa/solvers/linear/mkl_pardiso_solver.h"
#include "fesa/solvers/linear/mkl_pardiso_tangent_solver.h"
namespace {
using Frame = fesa::DynamicAcceptedFrameState;
using Assembly = fesa::hht_internal::DynamicAssembly;
using L3 = std::array<long double, 3>;
constexpr double kEndTime = 0.25;
std::string Message(const fesa::Status& status) {
return status.Diagnostics().empty()
? "Unspecified solver failure"
: status.Diagnostics().front().code + ": " +
status.Diagnostics().front().message;
}
void Require(const fesa::Status& status) {
if (!status.IsOk()) throw std::runtime_error{Message(status)};
}
template <typename T>
T Require(fesa::Result<T> result) {
if (!result.HasValue()) throw std::runtime_error{Message(result.GetStatus())};
return std::move(result.Value());
}
L3 Add(const L3& a, const L3& b) {
return {a[0] + b[0], a[1] + b[1], a[2] + b[2]};
}
L3 Scale(const L3& a, const long double factor) {
return {factor * a[0], factor * a[1], factor * a[2]};
}
L3 Cross(const L3& a, const L3& b) {
return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]};
}
long double Dot(const L3& a, const L3& b) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
long double Norm(const L3& a) {
return std::hypot(a[0], std::hypot(a[1], a[2]));
}
L3 Triple(const fesa::Vector& vector, const std::size_t offset) {
return {vector[offset], vector[offset + 1U], vector[offset + 2U]};
}
L3 Coordinates(const fesa::Node& node) {
return {node.coordinates[0], node.coordinates[1], node.coordinates[2]};
}
void Store(const L3& value, fesa::Vector* vector, const std::size_t offset) {
for (std::size_t c = 0; c < 3; ++c)
(*vector)[offset + c] = static_cast<double>(value[c]);
}
// Independent subset-block exponential, with no Rodrigues/Jl scalar formulas.
// The final block gives the mixed derivative in the supplied chart directions.
L3 ExponentialDerivative(const L3& phi, const L3& initial,
const std::vector<L3>& directions = {}) {
std::array<L3, 16> term{};
std::array<L3, 16> sum{};
term[0] = sum[0] = initial;
const std::size_t blocks = std::size_t{1} << directions.size();
for (std::size_t order = 1U; order <= 64U; ++order) {
std::array<L3, 16> next{};
for (std::size_t subset = 0; subset < blocks; ++subset) {
next[subset] = Cross(phi, term[subset]);
for (std::size_t direction = 0; direction < directions.size();
++direction) {
const std::size_t bit = std::size_t{1} << direction;
if ((subset & bit) != 0U)
next[subset] = Add(next[subset],
Cross(directions[direction], term[subset ^ bit]));
}
next[subset] =
Scale(next[subset], 1.0L / static_cast<long double>(order));
sum[subset] = Add(sum[subset], next[subset]);
}
term = next;
}
return sum[blocks - 1U];
}
struct Fixture {
std::unique_ptr<fesa::Domain> domain;
fesa::DofManager dofs;
std::vector<fesa::hht_internal::RuntimeShell> shells;
double length;
};
Fixture MakeFixture(const std::size_t divisions,
const bool lifecycle_translation = false) {
fesa::ModelDefinition definition{};
definition.source_path = "hht-shell-physics.inp";
definition.source_content_identity = "internal-C08-fixture";
for (std::size_t y = 0; y <= divisions; ++y) {
for (std::size_t x = 0; x <= divisions; ++x) {
const auto index = definition.nodes.size();
const auto label = static_cast<std::int64_t>(index + 1U);
definition.nodes.push_back({{"Plate", label, std::to_string(label)},
{-1.0 + 2.0 * static_cast<double>(x) /
static_cast<double>(divisions),
-1.0 + 2.0 * static_cast<double>(y) /
static_cast<double>(divisions),
0.0},
{}});
definition.shell_node_initial_frames.push_back(
{static_cast<fesa::EntityIndex>(index),
{0.0, 0.0, 1.0},
{1.0, 0.0, 0.0},
{0.0, 1.0, 0.0}});
}
}
definition.materials = {{"Elastic", 1000.0, 0.3, {}}};
definition.densities = {{0U, 1.0, {}}};
definition.shell_sections = {{"Centered", 0.2, 0U, {}}};
for (std::size_t y = 0; y < divisions; ++y) {
for (std::size_t x = 0; x < divisions; ++x) {
const auto first =
static_cast<fesa::EntityIndex>(y * (divisions + 1U) + x);
const auto stride = static_cast<fesa::EntityIndex>(divisions + 1U);
const auto label =
static_cast<std::int64_t>(definition.shell_elements.size() + 1U);
definition.shell_elements.push_back(
{{"Plate", label, std::to_string(label)},
fesa::ShellSourceElementType::kS4,
{first, first + 1U, first + stride + 1U, first + stride},
0U,
0U,
{}});
}
}
fesa::DynamicStepDefinition step{};
step.source_step_name_raw = "C08";
step.source_step_name_canonical = "C08";
step.initial_increment = 1.0 / 64.0;
step.time_period = kEndTime;
step.increment_count = 16U;
if (lifecycle_translation) {
std::vector<fesa::EntityIndex> nodes;
for (std::size_t node = 0U; node < definition.nodes.size(); ++node)
nodes.push_back(static_cast<fesa::EntityIndex>(node));
definition.node_sets.push_back({"All", std::nullopt, nodes, {}});
step.loads = {{"All", 1, 0.2, {}}};
step.increment_count = 2U;
step.time_period = 2.0 * step.initial_increment;
}
definition.dynamic_step = step;
auto domain = std::make_unique<fesa::Domain>(
Require(fesa::Domain::Create(std::move(definition))));
auto model = Require(fesa::AnalysisModel::Create(*domain));
auto dofs = Require(fesa::DofManager::Create(model));
auto shells = Require(fesa::hht_internal::BuildRuntimeShells(*domain, dofs));
const double length = Require(fesa::hht_internal::ReferenceLength(*domain));
return {std::move(domain), std::move(dofs), std::move(shells), length};
}
Frame EmptyFrame(const Fixture& fixture) {
Frame frame{};
frame.is_initial = true;
for (auto* vector :
{&frame.generalized_coordinates, &frame.velocity, &frame.acceleration,
&frame.algorithmic_acceleration, &frame.external_force}) {
*vector = fesa::Vector(fixture.dofs.FullDofCount());
}
return frame;
}
Assembly Evaluate(const Fixture& fixture, Frame frame, const double h,
const fesa::HhtParameters& parameters, const bool third) {
const fesa::SerialParallelFor parallel;
fesa::Vector load_scale(frame.external_force.Size());
for (std::size_t i = 0; i < load_scale.Size(); ++i)
load_scale[i] = std::abs(frame.external_force[i]);
return Require(fesa::hht_internal::EvaluateAssembly(
*fixture.domain, fixture.dofs, fixture.shells, std::move(frame),
load_scale, h, parameters, parallel, third));
}
struct VolumeOracle {
fesa::Vector force;
long double kinetic = 0.0L;
long double power = 0.0L;
long double power_scale = 0.0L;
L3 momentum{};
L3 angular_momentum{};
L3 momentum_rate{};
L3 angular_momentum_rate{};
long double momentum_scale = 0.0L;
long double angular_momentum_scale = 0.0L;
long double momentum_rate_scale = 0.0L;
long double angular_momentum_rate_scale = 0.0L;
};
// Independent nodal 5^3 rectangle quadrature and exponential kinematics.
// No production mass, inertia force, momentum, or director derivative is
// reused.
VolumeOracle Integrate(const Fixture& fixture, const Frame& frame) {
constexpr std::array<long double, 5> points{
-0.906179845938663992797626878299L, -0.538469310105683091036314420700L,
0.0L, 0.538469310105683091036314420700L,
0.906179845938663992797626878299L};
constexpr std::array<long double, 5> weights{
0.236926885056189087514264040720L, 0.478628670499366468041291514836L,
0.568888888888888888888888888889L, 0.478628670499366468041291514836L,
0.236926885056189087514264040720L};
constexpr std::array<std::array<int, 2>, 4> signs{
{{-1, -1}, {1, -1}, {1, 1}, {-1, 1}}};
VolumeOracle oracle{fesa::Vector(fixture.dofs.FullDofCount())};
std::vector<long double> force(fixture.dofs.FullDofCount(), 0.0L);
for (std::size_t element = 0;
element < fixture.domain->ShellElements().Size(); ++element) {
const auto& shell = fixture.domain->ShellElements()[element];
std::array<L3, 4> x{};
std::array<L3, 4> v{};
std::array<L3, 4> a{};
std::array<L3, 4> director{};
std::array<L3, 4> director_rate{};
std::array<L3, 4> director_acceleration{};
std::array<std::array<L3, 3>, 4> derivative{};
for (std::size_t node = 0; node < 4; ++node) {
const auto global = shell.node_indices[node];
const auto offset = 6U * global;
const L3 phi = Triple(frame.generalized_coordinates, offset + 3U);
const L3 phidot = Triple(frame.velocity, offset + 3U);
const L3 phiddot = Triple(frame.acceleration, offset + 3U);
x[node] = Add(Coordinates(fixture.domain->Nodes()[global]),
Triple(frame.generalized_coordinates, offset));
v[node] = Triple(frame.velocity, offset);
a[node] = Triple(frame.acceleration, offset);
director[node] = ExponentialDerivative(phi, {0.0L, 0.0L, 1.0L});
director_rate[node] =
ExponentialDerivative(phi, {0.0L, 0.0L, 1.0L}, {phidot});
director_acceleration[node] =
Add(ExponentialDerivative(phi, {0.0L, 0.0L, 1.0L}, {phidot, phidot}),
ExponentialDerivative(phi, {0.0L, 0.0L, 1.0L}, {phiddot}));
for (std::size_t c = 0; c < 3; ++c) {
L3 axis{};
axis[c] = 1.0L;
derivative[node][c] =
ExponentialDerivative(phi, {0.0L, 0.0L, 1.0L}, {axis});
}
}
const L3 edge_x =
Add(Coordinates(fixture.domain->Nodes()[shell.node_indices[1]]),
Scale(Coordinates(fixture.domain->Nodes()[shell.node_indices[0]]),
-1.0L));
const L3 edge_y =
Add(Coordinates(fixture.domain->Nodes()[shell.node_indices[3]]),
Scale(Coordinates(fixture.domain->Nodes()[shell.node_indices[0]]),
-1.0L));
const long double jacobian = Norm(Cross(edge_x, edge_y)) * 0.025L;
for (std::size_t i = 0; i < 5; ++i) {
for (std::size_t j = 0; j < 5; ++j) {
std::array<long double, 4> shape{};
for (std::size_t node = 0; node < 4; ++node)
shape[node] = 0.25L * (1.0L + signs[node][0] * points[i]) *
(1.0L + signs[node][1] * points[j]);
for (std::size_t k = 0; k < 5; ++k) {
const long double z = 0.1L * points[k];
const long double weight =
jacobian * weights[i] * weights[j] * weights[k];
for (std::size_t node = 0; node < 4; ++node) {
const long double nodal_weight = weight * shape[node];
const L3 position = Add(x[node], Scale(director[node], z));
const L3 velocity = Add(v[node], Scale(director_rate[node], z));
const L3 acceleration =
Add(a[node], Scale(director_acceleration[node], z));
oracle.kinetic += 0.5L * nodal_weight * Dot(velocity, velocity);
oracle.power += nodal_weight * Dot(velocity, acceleration);
oracle.power_scale +=
nodal_weight * Norm(velocity) * Norm(acceleration);
oracle.momentum =
Add(oracle.momentum, Scale(velocity, nodal_weight));
oracle.angular_momentum =
Add(oracle.angular_momentum,
Scale(Cross(position, velocity), nodal_weight));
oracle.momentum_rate =
Add(oracle.momentum_rate, Scale(acceleration, nodal_weight));
oracle.angular_momentum_rate =
Add(oracle.angular_momentum_rate,
Scale(Cross(position, acceleration), nodal_weight));
oracle.momentum_scale += nodal_weight * Norm(velocity);
oracle.angular_momentum_scale +=
nodal_weight * Norm(Cross(position, velocity));
oracle.momentum_rate_scale += nodal_weight * Norm(acceleration);
oracle.angular_momentum_rate_scale +=
nodal_weight * Norm(Cross(position, acceleration));
const auto offset = 6U * shell.node_indices[node];
for (std::size_t c = 0; c < 3; ++c) {
force[offset + c] += nodal_weight * acceleration[c];
force[offset + 3U + c] +=
nodal_weight * z * Dot(derivative[node][c], acceleration);
}
}
}
}
}
}
for (std::size_t i = 0; i < force.size(); ++i)
oracle.force[i] = static_cast<double>(force[i]);
return oracle;
}
std::array<L3, 5> OrbitChart(const double time) {
const long double t = time;
return {{{0.4L * std::sin(t), 0.6L * std::sin(0.7L * t),
0.2L * std::sin(1.3L * t)},
{0.4L * std::cos(t), 0.42L * std::cos(0.7L * t),
0.26L * std::cos(1.3L * t)},
{-0.4L * std::sin(t), -0.294L * std::sin(0.7L * t),
-0.338L * std::sin(1.3L * t)},
{-0.4L * std::cos(t), -0.2058L * std::cos(0.7L * t),
-0.4394L * std::cos(1.3L * t)},
{0.4L * std::sin(t), 0.14406L * std::sin(0.7L * t),
0.57122L * std::sin(1.3L * t)}}};
}
Frame RigidOrbit(const Fixture& fixture, const double time) {
Frame frame = EmptyFrame(fixture);
frame.time = time;
frame.is_initial = time == 0.0;
const auto chart = OrbitChart(time);
const auto& phi = chart[0];
const auto& velocity = chart[1];
const auto& acceleration = chart[2];
for (std::size_t node = 0; node < fixture.domain->Nodes().size(); ++node) {
const auto offset = 6U * node;
const L3 initial = Coordinates(fixture.domain->Nodes()[node]);
Store(Add(ExponentialDerivative(phi, initial), Scale(initial, -1.0L)),
&frame.generalized_coordinates, offset);
Store(phi, &frame.generalized_coordinates, offset + 3U);
Store(ExponentialDerivative(phi, initial, {velocity}), &frame.velocity,
offset);
Store(velocity, &frame.velocity, offset + 3U);
Store(Add(ExponentialDerivative(phi, initial, {velocity, velocity}),
ExponentialDerivative(phi, initial, {acceleration})),
&frame.acceleration, offset);
Store(acceleration, &frame.acceleration, offset + 3U);
}
frame.algorithmic_acceleration = frame.acceleration;
return frame;
}
std::array<L3, 3> OrbitPhysicalRates(const std::array<L3, 5>& chart,
const L3& initial) {
const auto& q = chart[0];
const auto& v = chart[1];
const auto& a = chart[2];
const auto& j = chart[3];
const auto& s = chart[4];
const auto d2 = Add(ExponentialDerivative(q, initial, {v, v}),
ExponentialDerivative(q, initial, {a}));
const auto d3 =
Add(Add(ExponentialDerivative(q, initial, {v, v, v}),
Scale(ExponentialDerivative(q, initial, {v, a}), 3.0L)),
ExponentialDerivative(q, initial, {j}));
const auto d4 =
Add(Add(ExponentialDerivative(q, initial, {v, v, v, v}),
Scale(ExponentialDerivative(q, initial, {v, v, a}), 6.0L)),
Add(Scale(ExponentialDerivative(q, initial, {a, a}), 3.0L),
Add(Scale(ExponentialDerivative(q, initial, {v, j}), 4.0L),
ExponentialDerivative(q, initial, {s}))));
return {d2, d3, d4};
}
// For the single centered rectangle, the nodal kinetic measure gives
// m_i=0.2 and j_i=m_i*t^2/12. Differentiate the nodal force moments.
std::array<fesa::Vector, 2> RigidForceRates(const Fixture& fixture,
const double time) {
std::array<fesa::Vector, 2> rates{fesa::Vector(24U), fesa::Vector(24U)};
const auto chart = OrbitChart(time);
const auto director = OrbitPhysicalRates(chart, {0.0L, 0.0L, 1.0L});
for (std::size_t node = 0; node < 4U; ++node) {
const auto x =
OrbitPhysicalRates(chart, Coordinates(fixture.domain->Nodes()[node]));
Store(Scale(x[1], 0.2L), &rates[0], 6U * node);
Store(Scale(x[2], 0.2L), &rates[1], 6U * node);
for (std::size_t c = 0; c < 3U; ++c) {
L3 axis{};
axis[c] = 1.0L;
const auto g =
ExponentialDerivative(chart[0], {0.0L, 0.0L, 1.0L}, {axis});
const auto dg =
ExponentialDerivative(chart[0], {0.0L, 0.0L, 1.0L}, {axis, chart[1]});
const auto ddg = Add(ExponentialDerivative(chart[0], {0.0L, 0.0L, 1.0L},
{axis, chart[1], chart[1]}),
ExponentialDerivative(chart[0], {0.0L, 0.0L, 1.0L},
{axis, chart[2]}));
rates[0][6U * node + 3U + c] = static_cast<double>(
(0.008L / 12.0L) * (Dot(dg, director[0]) + Dot(g, director[1])));
rates[1][6U * node + 3U + c] =
static_cast<double>((0.008L / 12.0L) * (Dot(ddg, director[0]) +
2.0L * Dot(dg, director[1]) +
Dot(g, director[2])));
}
}
return rates;
}
double SparseNorm(const fesa::SparseMatrix& matrix) {
double norm = 0.0;
for (const double value : matrix.Values()) norm = std::hypot(norm, value);
return norm;
}
// The manufactured F(t) is prescribed in generalized coordinates. Its null
// work vanishes on the exact orbit, but not at a Newton trial. Include every
// explicit-time term of psi=n(q)^T(f_int(q)-F(t)); the public dead-load helper
// deliberately does not implement this verification-only load convention.
void ManufacturedHidden(const Assembly& assembly,
const std::array<fesa::Vector, 2>& force_rates,
Frame* frame) {
const auto nodes = assembly.rotations.size();
for (auto* vector :
{&frame->hidden_constraint, &frame->hidden_constraint_scale,
&frame->hidden_velocity_defect, &frame->hidden_velocity_defect_scale,
&frame->hidden_acceleration_defect,
&frame->hidden_acceleration_defect_scale})
*vector = fesa::Vector(nodes);
for (std::size_t node = 0; node < nodes; ++node) {
const auto& rotation = assembly.rotations[node];
double psi = 0.0;
double psi_scale = 0.0;
double first = 0.0;
double first_scale = 0.0;
double second = assembly.hidden_second[node];
double second_scale = assembly.hidden_second_scale[node];
auto add = [](const double term, double* value, double* scale) {
*value += term;
*scale += std::abs(term);
};
for (std::size_t c = 0; c < 3U; ++c) {
const auto row = 6U * node + 3U + c;
const double n = rotation.drill_null[c];
const double g = frame->internal_force[row] - frame->external_force[row];
psi += n * g;
psi_scale += std::abs(n) * frame->residual_scale[row];
for (std::size_t d = 0; d < 3U; ++d) {
const auto column = 6U * node + 3U + d;
const double dn = rotation.null_gradient(c, d);
add(dn * g * frame->velocity[column], &first, &first_scale);
add(dn * g * frame->acceleration[column], &second, &second_scale);
add(-2.0 * dn * frame->velocity[column] * force_rates[0][row], &second,
&second_scale);
}
const auto& stiffness = assembly.internal_tangent;
for (std::size_t index = stiffness.RowOffsets()[row];
index < stiffness.RowOffsets()[row + 1U]; ++index) {
const auto column = stiffness.ColumnIndices()[index];
const double gradient = n * stiffness.Values()[index];
add(gradient * frame->velocity[column], &first, &first_scale);
add(gradient * frame->acceleration[column], &second, &second_scale);
}
add(-n * force_rates[0][row], &first, &first_scale);
add(-n * force_rates[1][row], &second, &second_scale);
}
frame->hidden_constraint[node] = psi;
frame->hidden_constraint_scale[node] = psi_scale;
frame->hidden_velocity_defect[node] = first;
frame->hidden_velocity_defect_scale[node] = first_scale;
frame->hidden_acceleration_defect[node] = second;
frame->hidden_acceleration_defect_scale[node] = second_scale;
}
}
void CompleteManufacturedConstraints(
const Fixture& fixture, const Assembly& assembly,
const std::vector<std::size_t>& initial_null_nodes,
fesa::MklPardisoSolver* positive, fesa::MklPardisoTangentSolver* tangent,
Frame* frame) {
// This read-only probe exercises current positive mass, null inventory,
// psi and psi_q regularity. psi_q includes n'*(f_int-F), including moments.
// Its autonomous hidden-rate outputs are discarded. Explicit time terms
// and initial rate consistency are evaluated separately below.
auto probe = assembly.frame;
probe.is_initial = false;
Require(fesa::hht_internal::CompleteConstraintEvidence(
*fixture.domain, fixture.dofs, assembly, fixture.length,
initial_null_nodes, *positive, *tangent, &probe));
ManufacturedHidden(assembly, RigidForceRates(fixture, frame->time), frame);
if (frame->is_initial) {
for (std::size_t node = 0; node < assembly.rotations.size(); ++node) {
for (const auto quantity :
{std::make_pair(&frame->hidden_velocity_defect,
&frame->hidden_velocity_defect_scale),
std::make_pair(&frame->hidden_acceleration_defect,
&frame->hidden_acceleration_defect_scale)}) {
const double value = std::abs((*quantity.first)[node]);
const double scale = (*quantity.second)[node];
if (scale == 0.0)
EXPECT_DOUBLE_EQ(value, 0.0);
else
EXPECT_LE(value / scale, 1.0e-10);
}
}
}
}
TEST(HhtShellPhysics, NodalRigidForceRatesMatchIndependentTimeDifferences) {
const auto fixture = MakeFixture(1U);
constexpr double time = 0.37;
const auto rates = RigidForceRates(fixture, time);
for (const double delta : {0.02, 0.01, 0.005}) {
SCOPED_TRACE(delta);
std::array<fesa::Vector, 5> forces{fesa::Vector(24U), fesa::Vector(24U),
fesa::Vector(24U), fesa::Vector(24U),
fesa::Vector(24U)};
for (std::size_t sample = 0; sample < forces.size(); ++sample) {
const double sample_time =
time + (static_cast<double>(sample) - 2.0) * delta;
forces[sample] =
Integrate(fixture, RigidOrbit(fixture, sample_time)).force;
}
for (std::size_t derivative = 0; derivative < 2U; ++derivative) {
for (const bool rotary : {false, true}) {
SCOPED_TRACE(derivative);
SCOPED_TRACE(rotary);
double error = 0.0;
double scale = 0.0;
for (std::size_t row = 0; row < 24U; ++row) {
if ((row % 6U >= 3U) != rotary) continue;
const double difference =
derivative == 0U ? (forces[0][row] - 8.0 * forces[1][row] +
8.0 * forces[3][row] - forces[4][row]) /
(12.0 * delta)
: (-forces[0][row] + 16.0 * forces[1][row] -
30.0 * forces[2][row] +
16.0 * forces[3][row] - forces[4][row]) /
(12.0 * delta * delta);
error = std::hypot(error, rates[derivative][row] - difference);
scale = std::hypot(scale, difference);
}
ASSERT_GT(scale, 0.0);
EXPECT_LE(error / scale, 1.0e-6);
}
}
}
}
TEST(HhtShellPhysics, ExternalDrillingHessianBalancesGradientAcceleration) {
const auto fixture = MakeFixture(1U);
const fesa::Vector3 phi{0.0, 0.0, 0.0};
const fesa::Vector3 velocity{1.0, 0.0, 1.0};
const fesa::Vector3 acceleration{0.0, -1.0 / 3.0, 0.0};
const fesa::Vector3 force{1.0, 0.0, 0.0};
const auto external = fixture.shells[0U].internal->EvaluateExternalDrillingConstraint(
0U, phi, velocity, force, {}, {});
ASSERT_TRUE(external.HasValue());
double gradient_acceleration = 0.0;
for (std::size_t component = 0U; component < 3U; ++component)
gradient_acceleration +=
external.Value().gradient[component] * acceleration[component];
EXPECT_NEAR(external.Value().directional_second, -1.0 / 6.0, 1.0e-14);
EXPECT_NEAR(gradient_acceleration, 1.0 / 6.0, 1.0e-14);
EXPECT_NEAR(external.Value().directional_second + gradient_acceleration,
0.0, 1.0e-14);
constexpr double step = 1.0e-4;
const auto plus = fixture.shells[0U].internal->EvaluateExternalDrillingConstraint(
0U, {step, 0.0, step}, {}, force, {}, {});
const auto middle = fixture.shells[0U].internal->EvaluateExternalDrillingConstraint(
0U, phi, {}, force, {}, {});
const auto minus = fixture.shells[0U].internal->EvaluateExternalDrillingConstraint(
0U, {-step, 0.0, -step}, {}, force, {}, {});
ASSERT_TRUE(plus.HasValue());
ASSERT_TRUE(middle.HasValue());
ASSERT_TRUE(minus.HasValue());
const double finite_difference =
(plus.Value().value - 2.0 * middle.Value().value + minus.Value().value) /
(step * step);
EXPECT_NEAR(finite_difference, external.Value().directional_second, 1.0e-8);
}
TEST(HhtShellPhysics, ManufacturedHiddenCountsExternalHessianOnce) {
const auto fixture = MakeFixture(1U);
auto frame = EmptyFrame(fixture);
frame.velocity[3U] = frame.velocity[5U] = 1.0;
frame.acceleration[4U] = -1.0 / 3.0;
frame.external_force[3U] = 1.0;
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
const auto assembly = Evaluate(fixture, frame, 1.0 / 64.0, parameters, true);
auto balance = assembly.frame;
std::array<fesa::Vector, 2U> zero_rates{
fesa::Vector(fixture.dofs.FullDofCount()),
fesa::Vector(fixture.dofs.FullDofCount())};
ManufacturedHidden(assembly, zero_rates, &balance);
constexpr std::size_t node = 0U;
double expected = assembly.hidden_second[node];
const auto& rotation = assembly.rotations[node];
for (std::size_t component = 0U; component < 3U; ++component) {
const auto row = 6U * node + 3U + component;
const double force =
assembly.frame.internal_force[row] - assembly.frame.external_force[row];
for (std::size_t direction = 0U; direction < 3U; ++direction)
expected += rotation.null_gradient(component, direction) * force *
assembly.frame.acceleration[6U * node + 3U + direction];
for (std::size_t index = assembly.internal_tangent.RowOffsets()[row];
index < assembly.internal_tangent.RowOffsets()[row + 1U]; ++index)
expected += rotation.drill_null[component] *
assembly.internal_tangent.Values()[index] *
assembly.frame.acceleration[
assembly.internal_tangent.ColumnIndices()[index]];
}
const double scale = assembly.hidden_second_scale[node] + std::abs(expected);
ASSERT_GT(scale, 0.0);
EXPECT_LE(std::abs(balance.hidden_acceleration_defect[node] - expected) /
scale,
1.0e-12);
}
TEST(HhtShellPhysics,
C08aRigidOrbitMatchesIndependentVolumeForcePowerAndMomentum) {
const auto fixture = MakeFixture(1U);
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
const auto initial =
Evaluate(fixture, EmptyFrame(fixture), 1.0 / 16.0, parameters, false);
const auto scaled_stiffness = Require(fesa::hht_internal::ScaledFree(
initial.internal_tangent, fixture.dofs, fixture.length));
double maximum_rotation = 0.0;
for (std::size_t sample = 0; sample <= 16; ++sample) {
const double time = static_cast<double>(sample) / 16.0;
SCOPED_TRACE(time);
auto exact = RigidOrbit(fixture, time);
const auto oracle = Integrate(fixture, exact);
exact.external_force = oracle.force;
const auto assembly =
Evaluate(fixture, exact, 1.0 / 16.0, parameters, true);
auto difference = assembly.frame.inertia_force;
difference.Axpy(-1.0, oracle.force);
EXPECT_LE(difference.Norm() / oracle.force.Norm(), 1.0e-12);
EXPECT_LE(std::abs(assembly.frame.kinetic_energy -
static_cast<double>(oracle.kinetic)) /
static_cast<double>(oracle.kinetic),
1.0e-12);
EXPECT_LE(std::abs(oracle.force.Dot(exact.velocity) -
static_cast<double>(oracle.power)) /
static_cast<double>(oracle.power_scale),
1.0e-10);
EXPECT_LE(assembly.frame.physical_strain_energy / 800.0, 1.0e-10);
EXPECT_LE(assembly.frame.drilling_energy / 800.0, 1.0e-10);
fesa::Vector scaled_q = exact.generalized_coordinates;
fesa::Vector scaled_force = assembly.frame.internal_force;
for (std::size_t i = 0; i < scaled_q.Size(); ++i) {
if (i % 6U < 3U) {
scaled_q[i] /= fixture.length;
scaled_force[i] *= fixture.length;
}
}
const double force_scale = SparseNorm(scaled_stiffness) * scaled_q.Norm();
if (force_scale == 0.0)
EXPECT_DOUBLE_EQ(scaled_force.Norm(), 0.0);
else
EXPECT_LE(scaled_force.Norm() / force_scale, 1.0e-10);
double momentum_error = 0.0;
double angular_error = 0.0;
for (std::size_t c = 0; c < 3; ++c) {
momentum_error = std::hypot(momentum_error,
assembly.frame.linear_momentum[c] -
static_cast<double>(oracle.momentum[c]));
angular_error = std::hypot(
angular_error, assembly.frame.angular_momentum[c] -
static_cast<double>(oracle.angular_momentum[c]));
}
EXPECT_LE(momentum_error / static_cast<double>(oracle.momentum_scale),
1.0e-12);
EXPECT_LE(
angular_error / static_cast<double>(oracle.angular_momentum_scale),
1.0e-12);
auto balance = assembly.frame;
ManufacturedHidden(assembly, RigidForceRates(fixture, time), &balance);
for (std::size_t node = 0; node < 4U; ++node) {
for (const auto quantity :
{std::make_pair(&balance.hidden_constraint,
&balance.hidden_constraint_scale),
std::make_pair(&balance.hidden_velocity_defect,
&balance.hidden_velocity_defect_scale),
std::make_pair(&balance.hidden_acceleration_defect,
&balance.hidden_acceleration_defect_scale)}) {
const double value = std::abs((*quantity.first)[node]);
const double scale = (*quantity.second)[node];
if (scale == 0.0)
EXPECT_DOUBLE_EQ(value, 0.0);
else
EXPECT_LE(value / scale, 1.0e-10);
}
}
EXPECT_TRUE(fesa::hht_internal::CompleteEquilibrium(
*fixture.domain, fixture.dofs, assembly, &balance)
.IsOk());
const double mass_norm = SparseNorm(assembly.mass);
for (std::size_t node = 0; node < 4U; ++node) {
fesa::Vector null(24U);
for (std::size_t c = 0; c < 3U; ++c)
null[6U * node + 3U + c] = assembly.rotations[node].drill_null[c];
EXPECT_LE(assembly.mass.Multiply(null).Norm() / mass_norm, 1.0e-12);
}
maximum_rotation = std::max(
maximum_rotation,
static_cast<double>(Norm(Triple(exact.generalized_coordinates, 3U))));
}
std::cout << "C08a pointwise independent-volume max_rotation="
<< std::setprecision(17) << maximum_rotation << '\n';
EXPECT_GT(maximum_rotation, 0.5);
}
// At q0=0 the normalized null is e_phi3 and f_int=0, hence psi_q is the
// corresponding stiffness row. Determine all null velocities, rather than
// assigning the unobservable director-axis chart rate arbitrarily.
void InitializeNullVelocity(const Fixture& fixture, const Assembly& initial,
Frame* frame,
fesa::MklPardisoTangentSolver* solver) {
const auto nodes = fixture.domain->Nodes().size();
std::vector<fesa::CooContribution> entries;
fesa::Vector rhs(nodes);
for (std::size_t node = 0; node < nodes; ++node) {
const auto row = 6U * node + 5U;
for (auto offset = initial.internal_tangent.RowOffsets()[row];
offset < initial.internal_tangent.RowOffsets()[row + 1U]; ++offset) {
const auto column = initial.internal_tangent.ColumnIndices()[offset];
const double value = initial.internal_tangent.Values()[offset];
if (column % 6U == 5U)
entries.push_back({node, column / 6U, value, 0U, entries.size()});
else
rhs[node] -= value * frame->velocity[column];
}
}
const auto regularity =
Require(fesa::hht_internal::MakeSparse(nodes, nodes, std::move(entries)));
fesa::Vector null_velocity(nodes);
Require(solver->FactorizeFresh(regularity));
Require(solver->SolveCorrection(rhs, null_velocity));
Require(fesa::hht_internal::CheckLinearSolve(regularity, rhs, null_velocity));
for (std::size_t node = 0; node < nodes; ++node)
frame->velocity[6U * node + 5U] = null_velocity[node];
}
struct GridEvidence {
double h;
double end_time;
std::vector<Frame> history;
std::array<double, 6> solve_noise{};
std::array<double, 6> arithmetic_noise{};
std::array<double, 6> selector_history_arithmetic_noise{};
std::array<double, 2> full_filter_arithmetic_noise{};
double energy_error = 0.0;
double momentum_error = 0.0;
double angular_momentum_error = 0.0;
double maximum_rotation = 0.0;
double algorithmic_acceleration_gap = 0.0;
double hidden_velocity = 0.0;
double hidden_acceleration = 0.0;
struct RecoveredAcceleration {
fesa::Vector value;
double pre_hidden2 = 0.0;
double pre_hidden2_relative = 0.0;
double post_hidden2 = 0.0;
double post_hidden2_relative = 0.0;
double mass_delta_a_relative = 0.0;
};
// These are diagnostic-only: RunPlate never substitutes them into Frame.
std::vector<RecoveredAcceleration> recovered_acceleration;
};
// Fixed-correction-path rounding radii for the carried-A recurrence. They
// bound arithmetic in the stored operation order only; Newton sensitivity is
// covered separately by the last-solve defect below.
struct ArithmeticRadii {
fesa::Vector coordinates;
fesa::Vector velocity;
fesa::Vector acceleration;
fesa::Vector algorithmic_acceleration;
};
double Up(const double value) {
if (!std::isfinite(value) || !(value >= 0.0))
return std::numeric_limits<double>::infinity();
return std::nextafter(value, std::numeric_limits<double>::infinity());
}
double UpSum(const double left, const double right) {
return Up(left + right);
}
double UpProduct(const double left, const double right) {
// Every caller is an upper nonnegative radius/product operation. Preserve
// exact zero support under an infinite inherited radius, but turn NaN or
// nonfinite nonzero products into infinity so max-based diagnostics cannot
// silently accept an incomplete certificate.
if (std::isnan(left) || std::isnan(right) || !(left >= 0.0) || !(right >= 0.0))
return std::numeric_limits<double>::infinity();
if (left == 0.0 || right == 0.0) return 0.0;
if (!std::isfinite(left) || !std::isfinite(right))
return std::numeric_limits<double>::infinity();
const double product = left * right;
return std::isfinite(product) ? Up(product)
: std::numeric_limits<double>::infinity();
}
double RoundoffRadius(const double value) {
const double u = std::ldexp(1.0, -53);
return UpSum(UpProduct(Up(u / (1.0 - u)), std::abs(value)),
std::numeric_limits<double>::denorm_min());
}
double AddRadius(const double result, const double left, const double right) {
return UpSum(UpSum(left, right), RoundoffRadius(result));
}
double ProductRadius(const double left_value, const double left_radius,
const double right_value, const double right_radius) {
const double result = left_value * right_value;
return UpSum(UpSum(UpProduct(std::abs(right_value), left_radius),
UpProduct(std::abs(left_value), right_radius)),
UpSum(UpProduct(left_radius, right_radius), RoundoffRadius(result)));
}
// Replay the actual fixed-branch Neumaier operations of rate reconstruction.
struct RateSumRadius {
double sum = 0.0, correction = 0.0;
double sum_radius = 0.0, correction_radius = 0.0;
void Add(const double term, const double term_radius) {
if (!std::isfinite(term) || !std::isfinite(term_radius) ||
!(term_radius >= 0.0))
throw std::runtime_error{"C08 arithmetic radius input is incomplete."};
const double next = sum + term;
const double next_radius = AddRadius(next, sum_radius, term_radius);
const bool sum_first = std::abs(sum) >= std::abs(term);
const double first = (sum_first ? sum : term) - next;
const double first_radius = AddRadius(first,
sum_first ? sum_radius : term_radius, next_radius);
const double error = first + (sum_first ? term : sum);
const double error_radius = AddRadius(error, first_radius,
sum_first ? term_radius : sum_radius);
correction += error;
correction_radius = AddRadius(correction, correction_radius, error_radius);
sum = next;
sum_radius = next_radius;
}
double Value() const { return sum + correction; }
double Radius() const {
return AddRadius(Value(), sum_radius, correction_radius);
}
};
double QuotientRadius(const double numerator_value, const double numerator_radius,
const double denominator_value,
const double denominator_radius) {
const double lower = std::nextafter(
std::abs(denominator_value) - denominator_radius,
-std::numeric_limits<double>::infinity());
if (!(lower > 0.0))
throw std::runtime_error{"C08 carried-Ar arithmetic denominator radius lost sign."};
const double result = numerator_value / denominator_value;
const double input = UpSum(numerator_radius,
UpProduct(std::abs(result), denominator_radius));
return UpSum(Up(input / lower), UpProduct(RoundoffRadius(result),
UpSum(1.0, Up(denominator_radius / lower))));
}
namespace reduced = fesa::hht_reduced_internal;
fesa::Vector ProjectBasisRadii(
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& columns,
const fesa::Vector& full, const fesa::Vector& full_radii,
fesa::Vector* replay_center = nullptr) {
if (replay_center != nullptr) *replay_center = fesa::Vector(columns.size());
fesa::Vector result(columns.size());
for (std::size_t column = 0U; column < columns.size(); ++column) {
const auto& basis = columns[column];
if (basis.support.size() != basis.support_radii.size())
throw std::runtime_error{"C08 basis projection radius inventory is invalid."};
RateSumRadius sum;
for (std::size_t i = 0U; i < basis.support.size(); ++i) {
const auto& entry = basis.support[i];
if (entry.dof >= full.Size() || entry.dof >= full_radii.Size() ||
!std::isfinite(basis.support_radii[i]))
throw std::runtime_error{"C08 basis projection radius support is invalid."};
const double term = entry.value * full[entry.dof];
const double term_radius = ProductRadius(entry.value, basis.support_radii[i],
full[entry.dof], full_radii[entry.dof]);
sum.Add(term, term_radius);
}
if (replay_center != nullptr) (*replay_center)[column] = sum.Value();
result[column] = sum.Radius();
}
return result;
}
void AccumulateLiftBasisRadii(
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& columns,
const fesa::Vector& coordinates, const fesa::Vector& coordinate_radii,
std::vector<RateSumRadius>* sums) {
if (coordinates.Size() != columns.size() || coordinate_radii.Size() != columns.size())
throw std::runtime_error{"C08 basis lift radius inventory is invalid."};
for (std::size_t column = 0U; column < columns.size(); ++column) {
const auto& basis = columns[column];
if (basis.support.size() != basis.support_radii.size())
throw std::runtime_error{"C08 basis lift radius support inventory is invalid."};
for (std::size_t i = 0U; i < basis.support.size(); ++i) {
const auto& entry = basis.support[i];
if (entry.dof >= sums->size() || !std::isfinite(basis.support_radii[i]))
throw std::runtime_error{"C08 basis lift radius support is invalid."};
const double term = entry.value * coordinates[column];
const double term_radius = ProductRadius(entry.value, basis.support_radii[i],
coordinates[column], coordinate_radii[column]);
(*sums)[entry.dof].Add(term, term_radius);
}
}
}
struct BasisLiftReplay {
fesa::Vector center;
fesa::Vector radius;
};
BasisLiftReplay ReplayLiftBasisRadii(
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& columns,
const fesa::Vector& coordinates, const fesa::Vector& coordinate_radii,
const std::size_t full_count) {
std::vector<RateSumRadius> sums(full_count);
AccumulateLiftBasisRadii(columns, coordinates, coordinate_radii, &sums);
BasisLiftReplay result{fesa::Vector(full_count), fesa::Vector(full_count)};
for (std::size_t full = 0U; full < full_count; ++full) {
result.center[full] = sums[full].Value();
result.radius[full] = sums[full].Radius();
}
return result;
}
BasisLiftReplay ReplayLiftBasisRadii(
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& p_columns,
const fesa::Vector& p, const fesa::Vector& p_radii,
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& z_columns,
const fesa::Vector& z, const fesa::Vector& z_radii,
const std::size_t full_count) {
std::vector<RateSumRadius> sums(full_count);
// Match reduced::Lift: every p support precedes every z support.
AccumulateLiftBasisRadii(p_columns, p, p_radii, &sums);
AccumulateLiftBasisRadii(z_columns, z, z_radii, &sums);
BasisLiftReplay result{fesa::Vector(full_count), fesa::Vector(full_count)};
for (std::size_t full = 0U; full < full_count; ++full) {
result.center[full] = sums[full].Value();
result.radius[full] = sums[full].Radius();
}
return result;
}
fesa::Vector LiftBasisRadii(
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn>& columns,
const fesa::Vector& coordinates, const fesa::Vector& coordinate_radii,
const std::size_t full_count) {
return ReplayLiftBasisRadii(columns, coordinates, coordinate_radii, full_count).radius;
}
TEST(HhtShellPhysics, BasisCoefficientRadiusSurvivesSparseProjectionAndLift) {
// A zero stored coefficient still has construction uncertainty. Dropping
// its support radius would incorrectly erase the free angular full-row
// contribution when a nonzero private plane coordinate is lifted.
const fesa::hht_reduced_internal::FixedBasisColumn plane{
0U, 1U, true,
{{3U, 0.0}, {4U, 0.6}, {5U, 0.8}},
{0x1p-52, 0x1p-53, 0x1p-53}};
const std::vector<fesa::hht_reduced_internal::FixedBasisColumn> columns{plane};
fesa::Vector coordinate(1U);
coordinate[0U] = 4.0;
const fesa::Vector zero_coordinate_radius(1U);
const auto lifted = LiftBasisRadii(columns, coordinate,
zero_coordinate_radius, 6U);
EXPECT_GT(lifted[3U], 0.0);
EXPECT_GE(lifted[4U], 4.0 * 0x1p-53);
EXPECT_GE(lifted[5U], 4.0 * 0x1p-53);
fesa::Vector full(6U);
full[4U] = 2.0;
const fesa::Vector zero_full_radius(6U);
const auto projected = ProjectBasisRadii(columns, full, zero_full_radius);
EXPECT_GT(projected[0U], 2.0 * 0x1p-53);
}
TEST(HhtShellPhysics, BasisRadiusReplayMatchesCompensatedProjectionAndCombinedLift) {
const double large = std::ldexp(1.0, 53);
fesa::Vector full(3U);
full[0U] = large;
full[1U] = 1.0;
full[2U] = -large;
const fesa::Vector zero_full_radius(3U);
const reduced::FixedBasisColumn projection{
0U, 0U, false, {{0U, 1.0}, {1U, 1.0}, {2U, 1.0}}, {0.0, 0.0, 0.0}};
fesa::Vector projection_center(0U);
const auto projection_radius = ProjectBasisRadii({projection}, full,
zero_full_radius,
&projection_center);
reduced::FixedChart projection_chart{};
projection_chart.full_dof_count = 3U;
projection_chart.p_dofs = {0U};
projection_chart.p_columns = {projection};
const auto projected = Require(reduced::ProjectPhysical(projection_chart, full));
EXPECT_DOUBLE_EQ(projected[0U], 1.0);
EXPECT_DOUBLE_EQ(projection_center[0U], projected[0U]);
EXPECT_GT(projection_radius[0U], 0.0);
reduced::FixedChart lift_chart{};
lift_chart.full_dof_count = 1U;
lift_chart.p_dofs = {0U, 1U};
lift_chart.z_dofs = {2U};
lift_chart.p_columns = {
{0U, 0U, false, {{0U, 1.0}}, {0.0}},
{0U, 0U, false, {{0U, 1.0}}, {0.0}}};
lift_chart.z_columns = {{0U, 1U, false, {{0U, 1.0}}, {0.0}}};
fesa::Vector p(2U);
p[0U] = large;
p[1U] = 1.0;
const fesa::Vector z{1U, -large};
const auto replay = ReplayLiftBasisRadii(lift_chart.p_columns, p, fesa::Vector(2U),
lift_chart.z_columns, z, fesa::Vector(1U), 1U);
const auto lifted = Require(reduced::Lift(lift_chart, p, z));
EXPECT_DOUBLE_EQ(lifted[0U], 1.0);
EXPECT_DOUBLE_EQ(replay.center[0U], lifted[0U]);
double plain = 0.0;
for (const double value : {large, 1.0, -large}) plain += value;
EXPECT_DOUBLE_EQ(plain, 0.0);
const double target = 1.25;
const double gap = target - replay.center[0U];
const double target_radius = UpSum(replay.radius[0U],
UpSum(std::abs(gap), RoundoffRadius(gap)));
EXPECT_GE(target_radius, 0.25);
fesa::Vector small_p(2U);
small_p[0U] = 1.0;
const auto small_replay = ReplayLiftBasisRadii(
lift_chart.p_columns, small_p, fesa::Vector(2U), lift_chart.z_columns,
fesa::Vector(1U), fesa::Vector(1U), 1U);
const auto small_lifted = Require(reduced::Lift(
lift_chart, small_p, fesa::Vector(1U)));
EXPECT_DOUBLE_EQ(small_replay.center[0U], small_lifted[0U]);
EXPECT_DOUBLE_EQ(small_replay.center[0U], 1.0);
ASSERT_LT(small_replay.radius[0U], 0.25);
const double small_gap = 1.25 - small_replay.center[0U];
const double small_target_radius = UpSum(
small_replay.radius[0U],
UpSum(std::abs(small_gap), RoundoffRadius(small_gap)));
EXPECT_GE(small_target_radius, 0.25);
}
TEST(HhtShellPhysics, BasisLiftedAlgorithmicCorrectionUsesHhtFilterFactor) {
reduced::FixedChart chart{};
chart.full_dof_count = 2U;
chart.p_dofs = {0U};
chart.p_columns = {{0U, 1U, true, {{0U, 0.6}, {1U, 0.8}}, {0.0, 0.0}}};
fesa::Vector delta_a(2U);
delta_a[0U] = 1.2;
delta_a[1U] = 1.6;
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
const double delta_ar = (1.0 + parameters.alpha) * 2.0;
fesa::Vector delta_A = delta_a;
delta_A.Scale(1.0 + parameters.alpha);
const auto projected = Require(reduced::ProjectPhysical(chart, delta_A));
EXPECT_NEAR(projected[0U], delta_ar, 1.0e-15);
const auto omitted = Require(reduced::ProjectPhysical(chart, delta_a));
const double omission_scale = std::abs(omitted[0U]) + std::abs(delta_ar);
ASSERT_GT(omission_scale, 0.0);
EXPECT_GT(std::abs(omitted[0U] - delta_ar) / omission_scale, 1.0e-12);
}
TEST(HhtShellPhysics, CarriedArRadiiIncludeAbsorbedUpdatesAndInputHistory) {
ASSERT_EQ(std::fegetround(), FE_TONEAREST);
volatile double subnormal = std::numeric_limits<double>::denorm_min();
volatile double doubled = subnormal + subnormal;
ASSERT_DOUBLE_EQ(doubled, 2.0 * std::numeric_limits<double>::denorm_min());
const double tiny = std::ldexp(1.0, -54);
const double rounded = 1.0 + tiny;
ASSERT_DOUBLE_EQ(rounded, 1.0);
const double first = AddRadius(rounded, 0.0, 0.0);
EXPECT_GE(first, tiny);
const double second = AddRadius(rounded + tiny, first, 0.0);
EXPECT_GT(second, first);
EXPECT_GE(second, 2.0 * tiny);
EXPECT_GE(ProductRadius(2.0, tiny, 4.0, tiny), 6.0 * tiny);
EXPECT_GE(QuotientRadius(1.0, tiny, 2.0, 0.0), 0.5 * tiny);
EXPECT_THROW(QuotientRadius(1.0, 0.0, 1.0, 1.0), std::runtime_error);
EXPECT_TRUE(std::isinf(AddRadius(std::numeric_limits<double>::max(),
std::numeric_limits<double>::max(), 0.0)));
}
TEST(HhtShellPhysics, PrimaryCoordinateRetainsCorrectionAbsorbedByCarriedAr) {
// The unchanged LargeDIRECT fixture has a0=-800000, h=.25 and this pp.
const double pp = -11218.75;
const double factor = 0.275625 * 0.25 * 0.25;
const double ar = -pp / factor;
const double initial_p = pp + factor * ar;
const double delta_p = 1.0e-12;
const double next_ar = ar + delta_p / factor;
EXPECT_DOUBLE_EQ(pp + factor * next_ar, initial_p);
const double next_p = initial_p + delta_p;
EXPECT_GT(next_p, initial_p);
EXPECT_DOUBLE_EQ(next_p - initial_p, delta_p);
const double scale = std::abs(pp) + std::abs(factor * next_ar);
EXPECT_LE(std::abs(next_p - (pp + factor * next_ar)) / scale, 1.0e-12);
const double inherited_radius = 2.0e-10;
const double first_radius = AddRadius(next_p, inherited_radius, 0.0);
EXPECT_GT(first_radius, inherited_radius);
EXPECT_GT(AddRadius(next_p + delta_p, first_radius, 0.0), first_radius);
}
// Diagnostic error-free transform of one finite binary64 addition: exact
// input sum minus the stored sum. It does not modify the integrator state.
double AdditionLowPart(const double left, const double right, const double sum) {
const double right_virtual = sum - left;
return (left - (sum - right_virtual)) + (right - right_virtual);
}
// TwoSum preserves the exact high+delta sum as a pair. Only adding its low
// part to the previous low part rounds the represented pair total. The owned
// history radius enters once; the unused final low part encloses high output.
void AdvanceCoordinate(const double delta, double* high, double* low,
double* pair_radius) {
const double sum = *high + delta;
const double error = AdditionLowPart(*high, delta, sum);
const double low_sum = *low + error;
*high = sum + low_sum;
*low = AdditionLowPart(sum, low_sum, *high);
*pair_radius = UpSum(*pair_radius, RoundoffRadius(low_sum));
}
TEST(HhtShellPhysics, CompensatedCoordinateRetainsAbsorbedNewtonCorrections) {
const double delta = std::ldexp(1.0, -54);
double high = 1.0, low = 0.0, radius = 2.0e-10;
const double inherited_radius = radius;
AdvanceCoordinate(delta, &high, &low, &radius);
EXPECT_DOUBLE_EQ(high, 1.0);
EXPECT_DOUBLE_EQ(low, delta);
for (unsigned i = 1U; i < 4U; ++i)
AdvanceCoordinate(delta, &high, &low, &radius);
EXPECT_DOUBLE_EQ(high, 1.0 + std::ldexp(1.0, -52));
EXPECT_DOUBLE_EQ(low, 0.0);
EXPECT_GT(radius, inherited_radius);
EXPECT_GE(UpSum(radius, std::abs(low)), inherited_radius);
high = 1.0;
const double first = 1.0 + delta;
low = AdditionLowPart(1.0, delta, first) + AdditionLowPart(first, delta, first + delta);
radius = 0.0;
AdvanceCoordinate(delta, &high, &low, &radius);
EXPECT_DOUBLE_EQ(high, 1.0 + std::ldexp(1.0, -52));
EXPECT_DOUBLE_EQ(low, -delta);
high = std::numeric_limits<double>::denorm_min();
low = 0.0;
radius = 0.0;
AdvanceCoordinate(high, &high, &low, &radius);
EXPECT_DOUBLE_EQ(high, 2.0 * std::numeric_limits<double>::denorm_min());
EXPECT_DOUBLE_EQ(low, 0.0);
high = std::numeric_limits<double>::max();
AdvanceCoordinate(high, &high, &low, &radius);
EXPECT_FALSE(std::isfinite(high));
EXPECT_FALSE(std::isfinite(radius));
}
double HhtCoordinateFactorRadius(const fesa::HhtParameters& p, const double h) {
const double first = p.beta * h;
return ProductRadius(first, RoundoffRadius(first), h, 0.0);
}
double RadiusNorm(const fesa::Vector& radii, const std::size_t offset) {
if (offset + 3U > radii.Size())
throw std::runtime_error{"C08 radius channel is outside the full vector."};
return std::hypot(radii[offset], radii[offset + 1U], radii[offset + 2U]);
}
struct GraphBasisProducts {
fesa::Matrix graph;
fesa::Matrix physical;
fesa::Matrix graph_radius;
fesa::Matrix physical_radius;
};
struct GraphInverseCertificate {
fesa::Matrix inverse_action;
fesa::Matrix inverse_bound;
fesa::Matrix residual_operator_bound;
bool complete = false;
};
GraphBasisProducts ContractGraphBasis(
const reduced::ConstraintOperators& operators,
const reduced::FixedChart& chart) {
const auto contract = [&](const std::vector<reduced::FixedBasisColumn>& columns) {
fesa::Matrix value(operators.rows.size(), columns.size());
fesa::Matrix radius(operators.rows.size(), columns.size());
for (std::size_t row = 0U; row < operators.rows.size(); ++row) {
for (std::size_t column = 0U; column < columns.size(); ++column) {
const auto& basis = columns[column];
if (basis.support.size() != basis.support_radii.size())
throw std::runtime_error{"C08 graph basis radius inventory is invalid."};
RateSumRadius sum;
for (const auto& gradient : operators.rows[row].gradient) {
for (std::size_t support = 0U; support < basis.support.size(); ++support) {
const auto& entry = basis.support[support];
if (gradient.dof != entry.dof) continue;
sum.Add(gradient.value * entry.value,
ProductRadius(gradient.value, 0.0, entry.value,
basis.support_radii[support]));
}
}
value(row, column) = sum.Value();
radius(row, column) = sum.Radius();
}
}
return std::pair{std::move(value), std::move(radius)};
};
auto [graph, graph_radius] = contract(chart.z_columns);
auto [physical, physical_radius] = contract(chart.p_columns);
return {std::move(graph), std::move(physical), std::move(graph_radius),
std::move(physical_radius)};
}
fesa::SparseMatrix SparseFromDense(const fesa::Matrix& matrix) {
std::vector<fesa::CooContribution> entries;
for (std::size_t row = 0U; row < matrix.Rows(); ++row)
for (std::size_t column = 0U; column < matrix.Columns(); ++column)
if (matrix(row, column) != 0.0)
entries.push_back({row, column, matrix(row, column), 0U, entries.size()});
return Require(fesa::hht_internal::MakeSparse(matrix.Rows(), matrix.Columns(),
std::move(entries)));
}
double UpperRowSum(const fesa::Matrix& matrix, const std::size_t row) {
double sum = 0.0;
for (std::size_t column = 0U; column < matrix.Columns(); ++column)
sum = UpSum(sum, std::abs(matrix(row, column)));
return sum;
}
bool FiniteMatrix(const fesa::Matrix& matrix) {
for (std::size_t row = 0U; row < matrix.Rows(); ++row)
for (std::size_t column = 0U; column < matrix.Columns(); ++column)
if (!std::isfinite(matrix(row, column))) return false;
return true;
}
bool FiniteNonnegativeMatrix(const fesa::Matrix& matrix) {
for (std::size_t row = 0U; row < matrix.Rows(); ++row)
for (std::size_t column = 0U; column < matrix.Columns(); ++column)
if (!std::isfinite(matrix(row, column)) || !(matrix(row, column) >= 0.0))
return false;
return true;
}
bool FiniteVector(const fesa::Vector& vector) {
for (std::size_t i = 0U; i < vector.Size(); ++i)
if (!std::isfinite(vector[i])) return false;
return true;
}
bool FiniteNonnegativeVector(const fesa::Vector& vector) {
for (std::size_t i = 0U; i < vector.Size(); ++i)
if (!std::isfinite(vector[i]) || !(vector[i] >= 0.0)) return false;
return true;
}
bool HasInfiniteRadius(const fesa::Vector& vector) {
bool infinite = false;
for (std::size_t i = 0U; i < vector.Size(); ++i) {
if (std::isnan(vector[i]) || !(vector[i] >= 0.0))
throw std::runtime_error{"C08 graph arithmetic radius is invalid."};
infinite = infinite || std::isinf(vector[i]);
}
return infinite;
}
void FillInfinite(fesa::Vector* vector) {
for (std::size_t i = 0U; i < vector->Size(); ++i)
(*vector)[i] = std::numeric_limits<double>::infinity();
}
GraphInverseCertificate CertifyGraphInverse(const GraphBasisProducts& products,
fesa::TangentSolver* solver) {
const auto size = products.graph.Rows();
if (products.graph.Columns() != size || products.graph_radius.Rows() != size ||
products.graph_radius.Columns() != size)
throw std::runtime_error{"C08 graph certificate matrix inventory is invalid."};
if (!FiniteMatrix(products.graph) ||
!FiniteNonnegativeMatrix(products.graph_radius))
return {fesa::Matrix(size, size), fesa::Matrix(size, size),
fesa::Matrix(size, size), false};
if (size == 0U)
return {fesa::Matrix(0U, 0U), fesa::Matrix(0U, 0U), fesa::Matrix(0U, 0U), true};
const auto sparse = SparseFromDense(products.graph);
Require(solver->FactorizeFresh(sparse));
fesa::Matrix inverse(size, size);
for (std::size_t column = 0U; column < size; ++column) {
fesa::Vector unit(size), action(size);
unit[column] = 1.0;
Require(solver->SolveCorrection(unit, action));
Require(fesa::hht_internal::CheckLinearSolve(sparse, unit, action));
if (!FiniteVector(action))
return {fesa::Matrix(size, size), fesa::Matrix(size, size),
fesa::Matrix(size, size), false};
for (std::size_t row = 0U; row < size; ++row) inverse(row, column) = action[row];
}
fesa::Matrix hbar(size, size);
for (std::size_t row = 0U; row < size; ++row) {
for (std::size_t column = 0U; column < size; ++column) {
RateSumRadius sum;
for (std::size_t middle = 0U; middle < size; ++middle)
sum.Add(products.graph(row, middle) * inverse(middle, column),
ProductRadius(products.graph(row, middle), 0.0,
inverse(middle, column), 0.0));
const double defect = (row == column ? 1.0 : 0.0) - sum.Value();
hbar(row, column) = UpSum(std::abs(defect),
AddRadius(defect, 0.0, sum.Radius()));
}
}
double theta = 0.0;
for (std::size_t row = 0U; row < size; ++row)
theta = std::max(theta, UpperRowSum(hbar, row));
const double lower = std::nextafter(1.0 - theta,
-std::numeric_limits<double>::infinity());
if (!(lower > 0.0) || !std::isfinite(lower))
return {std::move(inverse), fesa::Matrix(size, size), std::move(hbar), false};
fesa::Matrix bound(size, size);
for (std::size_t row = 0U; row < size; ++row) {
double tail = 0.0;
for (std::size_t middle = 0U; middle < size; ++middle)
tail = UpSum(tail, UpProduct(std::abs(inverse(row, middle)),
UpperRowSum(hbar, middle)));
tail = Up(tail / lower);
for (std::size_t column = 0U; column < size; ++column)
bound(row, column) = UpSum(std::abs(inverse(row, column)), tail);
}
return {std::move(inverse), std::move(bound), std::move(hbar), true};
}
void AddPhysicalContractionRadius(const GraphBasisProducts& products,
const fesa::Vector& coordinates,
const fesa::Vector& coordinate_radii,
fesa::Vector* rhs_radius) {
if (coordinates.Size() != products.physical.Columns() ||
coordinate_radii.Size() != coordinates.Size() ||
rhs_radius == nullptr || rhs_radius->Size() != products.physical.Rows())
throw std::runtime_error{"C08 physical graph-radius inventory is invalid."};
for (std::size_t row = 0U; row < products.physical.Rows(); ++row)
for (std::size_t column = 0U; column < products.physical.Columns(); ++column)
(*rhs_radius)[row] = UpSum((*rhs_radius)[row], ProductRadius(
products.physical(row, column), products.physical_radius(row, column),
coordinates[column], coordinate_radii[column]));
}
fesa::Vector BoundGraphSolution(const GraphBasisProducts& products,
const GraphInverseCertificate& inverse,
const fesa::Vector& rhs,
const fesa::Vector& rhs_radius,
const fesa::Vector& actual_center) {
const auto size = products.graph.Rows();
if (!inverse.complete || rhs.Size() != size || rhs_radius.Size() != size ||
actual_center.Size() != size)
throw std::runtime_error{"C08 graph certificate is incomplete."};
if (!FiniteMatrix(products.graph) ||
!FiniteNonnegativeMatrix(products.graph_radius) ||
!FiniteMatrix(inverse.inverse_action) ||
!FiniteNonnegativeMatrix(inverse.inverse_bound) ||
!FiniteNonnegativeMatrix(inverse.residual_operator_bound) ||
!FiniteVector(rhs) || !FiniteNonnegativeVector(rhs_radius) ||
!FiniteVector(actual_center))
throw std::runtime_error{"C08 graph certificate has nonfinite arithmetic input."};
// `actual_center` is the accepted graph/rate solve authority. Do not
// replace it with an independently rounded solve: this certificate bounds
// the actual mapped endpoint, while its N2-L evidence remains separate.
fesa::Vector rbar(size), source(size), y(size), row_a(size);
for (std::size_t row = 0U; row < size; ++row) {
RateSumRadius sum;
for (std::size_t column = 0U; column < size; ++column)
sum.Add(products.graph(row, column) * actual_center[column],
ProductRadius(products.graph(row, column), 0.0, actual_center[column], 0.0));
const double defect = rhs[row] - sum.Value();
rbar[row] = UpSum(std::abs(defect), AddRadius(defect, 0.0, sum.Radius()));
source[row] = UpSum(rbar[row], rhs_radius[row]);
for (std::size_t column = 0U; column < size; ++column)
source[row] = UpSum(source[row],
UpProduct(products.graph_radius(row, column), std::abs(actual_center[column])));
}
for (std::size_t row = 0U; row < size; ++row)
for (std::size_t column = 0U; column < size; ++column)
y[row] = UpSum(y[row], UpProduct(inverse.inverse_bound(row, column),
source[column]));
double theta = 0.0;
for (std::size_t row = 0U; row < size; ++row) {
for (std::size_t middle = 0U; middle < size; ++middle)
for (std::size_t column = 0U; column < size; ++column)
row_a[row] = UpSum(row_a[row], UpProduct(inverse.inverse_bound(row, middle),
products.graph_radius(middle, column)));
theta = std::max(theta, row_a[row]);
}
const double lower = std::nextafter(1.0 - theta,
-std::numeric_limits<double>::infinity());
if (!(lower > 0.0) || !std::isfinite(lower))
throw std::runtime_error{"C08 graph uncertainty feedback is incomplete."};
double norm_y = 0.0;
for (std::size_t row = 0U; row < size; ++row) norm_y = std::max(norm_y, y[row]);
fesa::Vector result(size);
for (std::size_t row = 0U; row < size; ++row)
result[row] = UpSum(y[row], UpProduct(row_a[row], Up(norm_y / lower)));
return result;
}
// N7 arithmetic INDICATOR with binary64 endpoint scalar/derivative operators
// frozen. This is first-order implicit sensitivity, not an enclosure of all
// FEM/AD operator evaluation, nonlinear branch, or equilibrium history error.
// CA selector history is retained separately; no radius is reset or clamped.
ArithmeticRadii GraphArithmeticIndicator(
const Frame& frame, const Frame& old,
const reduced::FixedChart& chart,
const reduced::ConstraintOperators& operators,
const ArithmeticRadii& selector_radii,
const ArithmeticRadii& old_radii, const fesa::HhtParameters& p,
fesa::MklPardisoTangentSolver* solver) {
auto result = selector_radii;
const auto nz = chart.z_columns.size();
if (nz == 0U) return result;
const bool inherited_incomplete =
HasInfiniteRadius(selector_radii.coordinates) ||
HasInfiniteRadius(selector_radii.velocity) ||
HasInfiniteRadius(selector_radii.acceleration) ||
HasInfiniteRadius(selector_radii.algorithmic_acceleration) ||
HasInfiniteRadius(old_radii.coordinates) ||
HasInfiniteRadius(old_radii.velocity) ||
HasInfiniteRadius(old_radii.acceleration) ||
HasInfiniteRadius(old_radii.algorithmic_acceleration);
if (inherited_incomplete) {
// +Inf is an inherited arithmetic bound, not a valid zero uncertainty.
// Retain it as INCONCLUSIVE without attempting max-based graph bounds.
FillInfinite(&result.coordinates);
FillInfinite(&result.velocity);
FillInfinite(&result.acceleration);
FillInfinite(&result.algorithmic_acceleration);
return result;
}
const auto products = ContractGraphBasis(operators, chart);
const auto graph = products.graph;
const auto assembled_graph = reduced::GraphJacobian(operators, chart);
for (std::size_t row = 0U; row < graph.Rows(); ++row)
for (std::size_t column = 0U; column < graph.Columns(); ++column)
if (graph(row, column) != assembled_graph(row, column))
throw std::runtime_error{"C08 graph CA replay differs from factored G."};
const auto inverse = CertifyGraphInverse(products, solver);
if (!inverse.complete)
throw std::runtime_error{"C08 graph inverse-action certificate is incomplete."};
const fesa::Vector zero_z(chart.z_columns.size());
const auto lift_p = [&](const fesa::Vector& coordinates) {
return Require(reduced::Lift(chart, coordinates, zero_z));
};
// Stored C/H/time entries are frozen inputs. The C*Lp/C*Lz replay below
// propagates immutable basis BL and source-order contraction rounding.
const auto p_q_coordinates = Require(reduced::ProjectPhysical(
chart, frame.generalized_coordinates));
const auto p_v_coordinates = Require(reduced::ProjectPhysical(chart, frame.velocity));
const auto p_a_coordinates = Require(reduced::ProjectPhysical(chart, frame.acceleration));
const auto p_q = lift_p(p_q_coordinates);
const auto p_v = lift_p(p_v_coordinates);
const auto p_a = lift_p(p_a_coordinates);
const auto z_q = Require(reduced::ProjectAlgebraic(chart, frame.generalized_coordinates));
const auto z_v = Require(reduced::ProjectAlgebraic(chart, frame.velocity));
const auto z_a = Require(reduced::ProjectAlgebraic(chart, frame.acceleration));
const auto p_coordinate_radii = ProjectBasisRadii(chart.p_columns,
frame.generalized_coordinates, selector_radii.coordinates);
const auto p_velocity_radii = ProjectBasisRadii(chart.p_columns,
frame.velocity, selector_radii.velocity);
const auto p_acceleration_radii = ProjectBasisRadii(chart.p_columns,
frame.acceleration, selector_radii.acceleration);
const auto p_q_full_radius = LiftBasisRadii(chart.p_columns,
p_q_coordinates,
p_coordinate_radii, chart.full_dof_count);
const auto p_v_full_radius = LiftBasisRadii(chart.p_columns,
p_v_coordinates,
p_velocity_radii, chart.full_dof_count);
const auto p_a_full_radius = LiftBasisRadii(chart.p_columns,
p_a_coordinates,
p_acceleration_radii, chart.full_dof_count);
for (std::size_t full = 0U; full < chart.full_dof_count; ++full) {
result.coordinates[full] = AddRadius(p_q[full], selector_radii.coordinates[full],
p_q_full_radius[full]);
result.velocity[full] = AddRadius(p_v[full], selector_radii.velocity[full],
p_v_full_radius[full]);
result.acceleration[full] = AddRadius(p_a[full], selector_radii.acceleration[full],
p_a_full_radius[full]);
}
const auto combine_lift_radius = [&](
const fesa::Vector& target, const fesa::Vector& inherited,
const fesa::Vector& p_coordinates, const fesa::Vector& p_radii,
const fesa::Vector& z_coordinates, const fesa::Vector& z_radii) {
const auto replay = ReplayLiftBasisRadii(chart.p_columns, p_coordinates, p_radii,
chart.z_columns, z_coordinates, z_radii,
chart.full_dof_count);
const auto actual = Require(reduced::Lift(chart, p_coordinates, z_coordinates));
fesa::Vector result(chart.full_dof_count);
for (std::size_t full = 0U; full < chart.full_dof_count; ++full) {
if (actual[full] != replay.center[full])
throw std::runtime_error{"C08 lift radius replay center differs from production Lift."};
const double gap = target[full] - replay.center[full];
const double gap_radius = UpSum(std::abs(gap), RoundoffRadius(gap));
result[full] = AddRadius(target[full], inherited[full],
UpSum(replay.radius[full], gap_radius));
}
return result;
};
const auto rate_defect = [&](const std::size_t row, const bool acceleration) {
const auto& op = operators.rows[row];
RateSumRadius rhs_sum;
if (acceleration) {
RateSumRadius hessian;
for (const auto& entry : op.hessian) {
const double first = entry.value * frame.velocity[entry.row];
hessian.Add(first * frame.velocity[entry.column], ProductRadius(first,
ProductRadius(entry.value, 0.0, frame.velocity[entry.row], 0.0),
frame.velocity[entry.column], 0.0));
}
RateSumRadius time_velocity;
for (const auto& entry : op.time_gradient)
time_velocity.Add(entry.value * frame.velocity[entry.dof],
ProductRadius(entry.value, 0.0, frame.velocity[entry.dof], 0.0));
rhs_sum.Add(-hessian.Value(), hessian.Radius());
rhs_sum.Add(-2.0 * time_velocity.Value(), ProductRadius(
2.0, 0.0, time_velocity.Value(), time_velocity.Radius()));
rhs_sum.Add(-op.time_second, 0.0);
} else {
rhs_sum.Add(-op.time_first, 0.0);
}
const auto& p_channel = acceleration ? p_a : p_v;
for (const auto& entry : op.gradient)
rhs_sum.Add(-entry.value * p_channel[entry.dof],
ProductRadius(entry.value, 0.0, p_channel[entry.dof], 0.0));
const double rhs = rhs_sum.Value();
const double radius = rhs_sum.Radius();
const auto& z_channel = acceleration ? z_a : z_v;
double dot = 0.0;
double dot_radius = 0.0;
for (std::size_t column = 0U; column < nz; ++column) {
if (graph(row, column) == 0.0) continue;
const double term = graph(row, column) * z_channel[column];
dot += term;
dot_radius = AddRadius(dot, dot_radius, ProductRadius(
graph(row, column), 0.0, z_channel[column], 0.0));
}
const double residual = dot - rhs;
return UpSum(std::abs(residual), AddRadius(residual, dot_radius, radius));
};
fesa::Vector position_rhs(nz), velocity_rhs(nz), acceleration_rhs(nz);
for (std::size_t row = 0U; row < nz; ++row) {
position_rhs[row] = UpSum(std::abs(operators.rows[row].value),
RoundoffRadius(operators.rows[row].value));
for (const auto& entry : operators.rows[row].gradient)
position_rhs[row] = UpSum(position_rhs[row],
UpProduct(std::abs(entry.value), result.coordinates[entry.dof]));
}
AddPhysicalContractionRadius(products, Require(reduced::ProjectPhysical(
chart, frame.generalized_coordinates)), p_coordinate_radii, &position_rhs);
const auto bz = BoundGraphSolution(products, inverse, graph.Multiply(z_q),
position_rhs, z_q);
result.coordinates = combine_lift_radius(frame.generalized_coordinates,
selector_radii.coordinates, p_q_coordinates, p_coordinate_radii, z_q, bz);
for (std::size_t row = 0U; row < nz; ++row) {
const auto& op = operators.rows[row];
double first = op.time_first;
double first_radius = 0.0;
for (const auto& entry : op.gradient) {
first += entry.value * frame.velocity[entry.dof];
first_radius = AddRadius(first, first_radius,
ProductRadius(entry.value, 0.0, frame.velocity[entry.dof], 0.0));
velocity_rhs[row] = UpSum(velocity_rhs[row],
UpProduct(std::abs(entry.value), result.velocity[entry.dof]));
}
for (const auto& entry : op.hessian)
velocity_rhs[row] = UpSum(velocity_rhs[row], UpProduct(
UpProduct(std::abs(entry.value), std::abs(frame.velocity[entry.column])),
result.coordinates[entry.row]));
for (const auto& entry : op.time_gradient)
velocity_rhs[row] = UpSum(velocity_rhs[row],
UpProduct(std::abs(entry.value), result.coordinates[entry.dof]));
velocity_rhs[row] = UpSum(velocity_rhs[row],
UpSum(rate_defect(row, false), UpSum(std::abs(first), first_radius)));
}
AddPhysicalContractionRadius(products, Require(reduced::ProjectPhysical(
chart, frame.velocity)), p_velocity_radii, &velocity_rhs);
const auto bvz = BoundGraphSolution(products, inverse, graph.Multiply(z_v),
velocity_rhs, z_v);
result.velocity = combine_lift_radius(frame.velocity, selector_radii.velocity,
p_v_coordinates, p_velocity_radii, z_v, bvz);
for (std::size_t row = 0U; row < nz; ++row) {
const auto& op = operators.rows[row];
double second = 0.0;
double second_radius = 0.0;
for (const auto& entry : op.hessian) {
const double first = entry.value * frame.velocity[entry.row];
second += first * frame.velocity[entry.column];
second_radius = AddRadius(second, second_radius, ProductRadius(first,
ProductRadius(entry.value, 0.0, frame.velocity[entry.row], 0.0),
frame.velocity[entry.column], 0.0));
acceleration_rhs[row] = UpSum(acceleration_rhs[row], UpProduct(
UpProduct(std::abs(entry.value), std::abs(frame.acceleration[entry.column])),
result.coordinates[entry.row]));
acceleration_rhs[row] = UpSum(acceleration_rhs[row], UpProduct(2.0, UpProduct(
UpProduct(std::abs(entry.value), std::abs(frame.velocity[entry.column])),
result.velocity[entry.row])));
}
for (const auto& entry : op.third_directional_gradient)
acceleration_rhs[row] = UpSum(acceleration_rhs[row],
UpProduct(std::abs(entry.value), result.coordinates[entry.dof]));
for (const auto& entry : op.time_gradient) {
const double first = 2.0 * entry.value;
second += first * frame.velocity[entry.dof];
second_radius = AddRadius(second, second_radius, ProductRadius(first,
ProductRadius(2.0, 0.0, entry.value, 0.0), frame.velocity[entry.dof], 0.0));
acceleration_rhs[row] = UpSum(acceleration_rhs[row], UpProduct(2.0,
UpProduct(std::abs(entry.value), result.velocity[entry.dof])));
}
second += op.time_second;
second_radius = AddRadius(second, second_radius, 0.0);
for (const auto& entry : op.gradient) {
second += entry.value * frame.acceleration[entry.dof];
second_radius = AddRadius(second, second_radius,
ProductRadius(entry.value, 0.0, frame.acceleration[entry.dof], 0.0));
acceleration_rhs[row] = UpSum(acceleration_rhs[row],
UpProduct(std::abs(entry.value), result.acceleration[entry.dof]));
}
acceleration_rhs[row] = UpSum(acceleration_rhs[row],
UpSum(rate_defect(row, true), UpSum(std::abs(second), second_radius)));
}
AddPhysicalContractionRadius(products, Require(reduced::ProjectPhysical(
chart, frame.acceleration)), p_acceleration_radii, &acceleration_rhs);
const auto baz = BoundGraphSolution(products, inverse, graph.Multiply(z_a),
acceleration_rhs, z_a);
result.acceleration = combine_lift_radius(frame.acceleration,
selector_radii.acceleration, p_a_coordinates, p_acceleration_radii, z_a, baz);
for (std::size_t i = 0U; i < chart.full_dof_count; ++i) {
result.algorithmic_acceleration[i] = AddRadius(
frame.algorithmic_acceleration[i], ProductRadius(1.0 + p.alpha,
RoundoffRadius(1.0 + p.alpha), frame.acceleration[i], result.acceleration[i]),
ProductRadius(p.alpha, 0.0, old.acceleration[i], old_radii.acceleration[i]));
}
return result;
}
TEST(HhtShellPhysics, FrozenGraphIndicatorIncludesCoordinateAndRateCurvature) {
// Independent polynomial graph z=p^2: vz=2*p*vp,
// az=2*vp^2+2*p*ap. Its first-order radius coefficients are exact.
reduced::FixedChart chart{};
chart.full_dof_count = 2U;
chart.p_dofs = {0U};
chart.z_dofs = {1U};
chart.p_columns = {{0U, 0U, false, {{0U, 1.0}}, {0.0}}};
chart.z_columns = {{0U, 1U, false, {{1U, 1.0}}, {0.0}}};
reduced::ConstraintOperators operators{};
operators.rows.resize(1U);
operators.rows[0].gradient = {{0U, -2.0}, {1U, 1.0}};
operators.rows[0].hessian = {{0U, 0U, -2.0}};
Frame frame{};
frame.generalized_coordinates = fesa::Vector(2U);
frame.velocity = fesa::Vector(2U);
frame.acceleration = fesa::Vector(2U);
frame.algorithmic_acceleration = fesa::Vector(2U);
frame.generalized_coordinates[0U] = frame.generalized_coordinates[1U] = 1.0;
frame.velocity[0U] = 1.0;
frame.velocity[1U] = 2.0;
frame.acceleration[0U] = 2.0;
frame.acceleration[1U] = 6.0;
Frame old = frame;
old.acceleration = fesa::Vector(2U);
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
for (std::size_t i = 0U; i < 2U; ++i)
frame.algorithmic_acceleration[i] = (1.0 + parameters.alpha) * frame.acceleration[i];
ArithmeticRadii selector{fesa::Vector(2U), fesa::Vector(2U),
fesa::Vector(2U), fesa::Vector(2U)};
const ArithmeticRadii zero = selector;
selector.coordinates[0U] = 1.0e-6;
selector.velocity[0U] = 1.0e-7;
selector.acceleration[0U] = 1.0e-8;
fesa::MklPardisoTangentSolver solver;
const auto indicator = GraphArithmeticIndicator(frame, old, chart, operators,
selector, zero, parameters, &solver);
EXPECT_GE(indicator.coordinates[1U], 2.0e-6);
EXPECT_GE(indicator.velocity[1U], 2.0e-6 + 2.0e-7);
EXPECT_GE(indicator.acceleration[1U], 4.0e-6 + 4.0e-7 + 2.0e-8);
EXPECT_TRUE(std::isfinite(indicator.acceleration[1U]));
EXPECT_GE(indicator.algorithmic_acceleration[1U],
(1.0 + parameters.alpha) * indicator.acceleration[1U]);
selector.coordinates[0U] = std::numeric_limits<double>::infinity();
const auto unresolved = GraphArithmeticIndicator(frame, old, chart, operators,
selector, zero, parameters, &solver);
EXPECT_TRUE(std::isinf(unresolved.coordinates[1U]));
EXPECT_TRUE(std::isinf(unresolved.velocity[1U]));
EXPECT_TRUE(std::isinf(unresolved.acceleration[1U]));
}
TEST(HhtShellPhysics, GraphBasisCertificateBoundsMatrixAndRhsPerturbations) {
const auto solve = [](const fesa::Matrix& matrix, const fesa::Vector& rhs) {
const auto sparse = SparseFromDense(matrix);
fesa::MklPardisoTangentSolver solver;
Require(solver.FactorizeFresh(sparse));
fesa::Vector value(rhs.Size());
Require(solver.SolveCorrection(rhs, value));
Require(fesa::hht_internal::CheckLinearSolve(sparse, rhs, value));
return value;
};
{
GraphBasisProducts products{fesa::Matrix(1U, 1U), fesa::Matrix(1U, 0U),
fesa::Matrix(1U, 1U), fesa::Matrix(1U, 0U)};
products.graph(0U, 0U) = 2.0;
products.graph_radius(0U, 0U) = 0.1;
fesa::MklPardisoTangentSolver solver;
const auto inverse = CertifyGraphInverse(products, &solver);
ASSERT_TRUE(inverse.complete);
const fesa::Vector rhs{1U, 1.0};
const fesa::Vector rhs_radius{1U, 0.01};
const auto center = solve(products.graph, rhs);
const auto bound = BoundGraphSolution(products, inverse, rhs, rhs_radius, center);
auto perturbed = products.graph;
perturbed(0U, 0U) = 1.95;
const auto actual = solve(perturbed, fesa::Vector{1U, 1.009});
EXPECT_LE(std::abs(actual[0U] - center[0U]), bound[0U]);
EXPECT_GT(bound[0U], 0.0);
// The actual mapped graph center is the certificate authority. Replacing
// it with a newly solved center would lose this distance when BG=Bb=0.
products.graph_radius(0U, 0U) = 0.0;
const fesa::Vector shifted_center{1U, 0.5 + std::ldexp(1.0, -30)};
const auto centered = BoundGraphSolution(products, inverse, rhs,
fesa::Vector(1U), shifted_center);
EXPECT_GE(centered[0U], std::ldexp(1.0, -30));
// A zero stored contribution preserves exact zero under an inherited
// +Inf radius, whereas NaN is invalid. The certificate must not let an
// invalid graph radius reach max-based feedback as a silent zero.
EXPECT_EQ(UpProduct(0.0, std::numeric_limits<double>::infinity()), 0.0);
EXPECT_TRUE(std::isinf(UpProduct(0.0, std::numeric_limits<double>::quiet_NaN())));
products.graph_radius(0U, 0U) = std::numeric_limits<double>::infinity();
EXPECT_FALSE(CertifyGraphInverse(products, &solver).complete);
EXPECT_THROW(BoundGraphSolution(products, inverse, rhs,
fesa::Vector(1U), center), std::runtime_error);
}
{
GraphBasisProducts products{fesa::Matrix(4U, 4U), fesa::Matrix(4U, 0U),
fesa::Matrix(4U, 4U), fesa::Matrix(4U, 0U)};
for (std::size_t i = 0U; i < 4U; ++i) {
products.graph(i, i) = 1.0;
products.graph_radius(i, i) = 0.95;
}
fesa::MklPardisoTangentSolver solver;
const auto inverse = CertifyGraphInverse(products, &solver);
ASSERT_TRUE(inverse.complete);
const fesa::Vector rhs(4U, 1.0);
const auto center = solve(products.graph, rhs);
const auto bound = BoundGraphSolution(products, inverse, rhs, fesa::Vector(4U), center);
auto perturbed = products.graph;
for (std::size_t i = 0U; i < 4U; ++i) perturbed(i, i) = 0.1;
const auto actual = solve(perturbed, rhs);
for (std::size_t i = 0U; i < 4U; ++i) {
EXPECT_LE(std::abs(actual[i] - center[i]), bound[i]);
// Without the A feedback term this would be only y=.95 and fail for 9.
EXPECT_GT(bound[i], 9.0);
}
products.graph_radius(0U, 0U) = 1.0;
const auto invalid_inverse = CertifyGraphInverse(products, &solver);
ASSERT_TRUE(invalid_inverse.complete);
EXPECT_THROW(BoundGraphSolution(products, invalid_inverse, rhs,
fesa::Vector(4U), center), std::runtime_error);
}
}
struct LastSolve {
reduced::AugmentedReducedSystem full_system;
reduced::AugmentedSolveSelection selected_system;
fesa::Vector selected_correction;
fesa::Vector full_correction;
};
// Read-only N7 probes retain the actual last Newton matrix, including all
// auxiliary rows. The endpoint RHS includes graph and both hidden defects.
void RecordNoise(const Fixture& fixture, const Assembly& accepted,
const reduced::FixedChart& chart,
const reduced::ConstraintOperators& operators,
const LastSolve& last, const fesa::HhtParameters& p,
const ArithmeticRadii& arithmetic_radii,
fesa::MklPardisoTangentSolver* solver,
GridEvidence* evidence) {
const auto solve_defect = [&](const fesa::SparseMatrix& tangent,
const fesa::Vector& correction,
const fesa::Vector& rhs) {
auto defect = tangent.Multiply(correction);
defect.Axpy(-1.0, rhs);
defect.Scale(-1.0);
fesa::Vector solution(defect.Size());
Require(solver->FactorizeFresh(tangent));
Require(solver->SolveCorrection(defect, solution));
Require(fesa::hht_internal::CheckLinearSolve(tangent, defect, solution));
return solution;
};
const auto selected_defect = solve_defect(
last.selected_system.tangent, last.selected_correction,
last.selected_system.rhs);
const auto selected_full = Require(reduced::EmbedAugmentedSolution(
last.selected_system, selected_defect, last.full_system.rhs.Size()));
fesa::Vector model_full(last.full_system.rhs.Size());
if (last.selected_system.angular_only)
model_full = solve_defect(last.full_system.tangent, last.full_correction,
last.full_system.rhs);
const double cv = p.gamma / (p.beta * evidence->h);
const double ca = 1.0 / ((1.0 + p.alpha) * p.beta * evidence->h * evidence->h);
auto endpoint = Require(reduced::AssembleAugmentedReducedSystem(
accepted, chart, operators, cv, ca, fixture.length, evidence->h));
const auto hessian = reduced::ContractConstraintHessian(
operators, accepted.frame.velocity, accepted.frame.velocity);
for (std::size_t row = 0U; row < chart.z_columns.size(); ++row) {
double first = operators.rows[row].time_first;
double second = hessian[row] + operators.rows[row].time_second;
for (const auto& entry : operators.rows[row].gradient) {
first += entry.value * accepted.frame.velocity[entry.dof];
second += entry.value * accepted.frame.acceleration[entry.dof];
}
for (const auto& entry : operators.rows[row].time_gradient)
second += 2.0 * entry.value * accepted.frame.velocity[entry.dof];
endpoint.rhs[endpoint.physical_count + row] =
-operators.rows[row].value * endpoint.row_scale[endpoint.physical_count + row];
endpoint.rhs[endpoint.physical_count + endpoint.algebraic_count + row] =
-first * endpoint.row_scale[
endpoint.physical_count + endpoint.algebraic_count + row];
endpoint.rhs[endpoint.physical_count + 2U * endpoint.algebraic_count + row] =
-second * endpoint.row_scale[
endpoint.physical_count + 2U * endpoint.algebraic_count + row];
}
fesa::Vector nonlinear_defect(endpoint.rhs.Size());
// The endpoint nonlinear probe uses its freshly assembled actual augmented
// matrix; the linear probe above belongs to the frozen last Newton matrix.
Require(solver->FactorizeFresh(endpoint.tangent));
Require(solver->SolveCorrection(endpoint.rhs, nonlinear_defect));
Require(fesa::hht_internal::CheckLinearSolve(endpoint.tangent, endpoint.rhs,
nonlinear_defect));
const auto last_full = Require(reduced::MapAugmentedCorrection(
chart, last.full_system, last.full_correction, cv, ca));
const auto selected_linear_full = Require(reduced::MapAugmentedCorrection(
chart, last.full_system, selected_full, cv, ca));
std::optional<reduced::AugmentedCorrection> model_linear_full;
if (last.selected_system.angular_only)
model_linear_full = Require(reduced::MapAugmentedCorrection(
chart, last.full_system, model_full, cv, ca));
const auto nonlinear_full = Require(reduced::MapAugmentedCorrection(
chart, endpoint, nonlinear_defect, cv, ca));
const std::array<const fesa::Vector*, 3> radii{
&arithmetic_radii.coordinates, &arithmetic_radii.velocity,
&arithmetic_radii.acceleration};
std::array<fesa::Vector, 3> selector_radii{
LiftBasisRadii(chart.p_columns,
Require(reduced::ProjectPhysical(chart, accepted.frame.generalized_coordinates)),
ProjectBasisRadii(chart.p_columns, accepted.frame.generalized_coordinates,
*radii[0U]), chart.full_dof_count),
LiftBasisRadii(chart.p_columns,
Require(reduced::ProjectPhysical(chart, accepted.frame.velocity)),
ProjectBasisRadii(chart.p_columns, accepted.frame.velocity,
*radii[1U]), chart.full_dof_count),
LiftBasisRadii(chart.p_columns,
Require(reduced::ProjectPhysical(chart, accepted.frame.acceleration)),
ProjectBasisRadii(chart.p_columns, accepted.frame.acceleration,
*radii[2U]), chart.full_dof_count)};
const std::array<const reduced::AugmentedCorrection*, 4> corrections{
&last_full, &selected_linear_full,
model_linear_full.has_value() ? &*model_linear_full : nullptr,
&nonlinear_full};
for (std::size_t node = 0U; node < fixture.domain->Nodes().size(); ++node)
for (std::size_t channel = 0U; channel < 2U; ++channel) {
const auto offset = 6U * node + 3U * channel;
const double scale = channel == 0U ? fixture.length : 1.0;
evidence->full_filter_arithmetic_noise[channel] = std::max(
evidence->full_filter_arithmetic_noise[channel], Up(UpProduct(
evidence->end_time * evidence->end_time,
RadiusNorm(arithmetic_radii.algorithmic_acceleration, offset)) / scale));
for (std::size_t rate = 0U; rate < 3U; ++rate) {
const double time_scale = rate == 0U ? 1.0 : rate == 1U
? evidence->end_time : evidence->end_time * evidence->end_time;
const auto channel_values = [&](const reduced::AugmentedCorrection& value) {
return rate == 0U ? &value.coordinate
: rate == 1U ? &value.velocity : &value.acceleration;
};
double eta = 0.0;
for (const auto* correction : corrections)
if (correction != nullptr)
eta += static_cast<double>(Norm(Triple(*channel_values(*correction),
offset)));
evidence->solve_noise[2U * rate + channel] = std::max(
evidence->solve_noise[2U * rate + channel], time_scale * eta / scale);
evidence->selector_history_arithmetic_noise[2U * rate + channel] = std::max(
evidence->selector_history_arithmetic_noise[2U * rate + channel],
Up(UpProduct(time_scale, RadiusNorm(selector_radii[rate], offset)) / scale));
evidence->arithmetic_noise[2U * rate + channel] = std::max(
evidence->arithmetic_noise[2U * rate + channel], Up(UpProduct(time_scale,
RadiusNorm(*radii[rate], offset)) / scale));
}
}
}
TEST(HhtShellPhysics, RestrictedLastSolvePreservesOmittedTranslationDefect) {
// p0 is translational and p1 is rotational. The restricted solve exactly
// satisfies its angular row, while the omitted U row remains coupled and
// must therefore contribute the separate full-model N7 solve.
reduced::FixedChart chart{};
chart.full_dof_count = 6U;
chart.p_dofs = {0U, 3U};
chart.p_columns = {{0U, 0U, false, {{0U, 1.0}}, {0.0}},
{0U, 1U, false, {{3U, 1.0}}, {0.0}}};
const auto tangent = Require(fesa::hht_internal::MakeSparse(2U, 2U,
{{0U, 0U, 1.0, 0U, 0U}, {0U, 1U, 2.0, 0U, 1U},
{1U, 0U, 3.0, 0U, 2U}, {1U, 1U, 1.0, 0U, 3U}}));
reduced::AugmentedReducedSystem full{tangent, fesa::Vector(2U), 2U, 0U,
fesa::Vector(2U, 1.0),
fesa::Vector(2U, 1.0)};
full.rhs[0U] = 0.0;
full.rhs[1U] = 1.0;
ASSERT_TRUE(reduced::ShouldRefineAngular(chart, {0.0, 1.0},
{0.0, 0.0, 0.0, 0.0}, true));
const auto selected = Require(reduced::SelectAugmentedSolve(full, chart, true));
ASSERT_TRUE(selected.angular_only);
ASSERT_EQ(selected.full_indices, std::vector<std::size_t>({1U}));
fesa::MklPardisoTangentSolver solver;
fesa::Vector angular(selected.rhs.Size());
Require(solver.FactorizeFresh(selected.tangent));
Require(solver.SolveCorrection(selected.rhs, angular));
Require(fesa::hht_internal::CheckLinearSolve(selected.tangent, selected.rhs,
angular));
const auto embedded = Require(reduced::EmbedAugmentedSolution(
selected, angular, full.rhs.Size()));
EXPECT_EQ(embedded[0U], 0.0);
EXPECT_EQ(embedded[1U], 1.0);
const auto selected_residual = selected.tangent.Multiply(angular);
EXPECT_EQ(selected_residual[0U] - selected.rhs[0U], 0.0);
auto full_defect = full.rhs;
full_defect.Axpy(-1.0, full.tangent.Multiply(embedded));
EXPECT_EQ(full_defect[0U], -2.0);
EXPECT_EQ(full_defect[1U], 0.0);
fesa::Vector full_model(full_defect.Size());
Require(solver.FactorizeFresh(full.tangent));
Require(solver.SolveCorrection(full_defect, full_model));
Require(fesa::hht_internal::CheckLinearSolve(full.tangent, full_defect,
full_model));
EXPECT_GT(std::abs(full_model[0U]), 0.0);
EXPECT_GT(std::abs(full_model[1U]), 0.0);
}
TEST(HhtShellPhysics, RestrictedRecordNoiseIncludesFullModelOmittedUDefect) {
// Keep the actual shell accepted frame/chart/hidden endpoint rows. The
// frozen last operator is a minimal full-size coupled matrix: its J rows
// are exactly solved while one omitted translational U row retains a
// nonzero full-model defect.
const auto fixture = MakeFixture(1U);
constexpr double h = 1.0 / 64.0;
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
const auto accepted = Evaluate(fixture, EmptyFrame(fixture), h, parameters, true);
const auto chart = Require(reduced::BuildFixedChart(fixture.dofs,
accepted.rotations));
const fesa::Vector zero(fixture.dofs.FullDofCount());
const auto operators = Require(reduced::EvaluateConstraintOperators(
*fixture.domain, fixture.dofs, fixture.shells, accepted, chart, zero, zero));
const double cv = parameters.gamma / (parameters.beta * h);
const double ca = 1.0 / ((1.0 + parameters.alpha) * parameters.beta * h * h);
const std::size_t total = chart.p_columns.size() + 3U * chart.z_columns.size();
std::size_t u = chart.p_columns.size();
std::size_t angular = chart.p_columns.size();
for (std::size_t i = 0U; i < chart.p_columns.size(); ++i) {
if (reduced::PhysicalCoordinateChannel(chart, i) == 0U) u = i;
else angular = i;
}
ASSERT_LT(u, chart.p_columns.size());
ASSERT_LT(angular, chart.p_columns.size());
std::vector<fesa::CooContribution> entries;
entries.reserve(total + 2U);
for (std::size_t i = 0U; i < total; ++i)
entries.push_back({i, i, 1.0, 0U, entries.size()});
entries.push_back({u, angular, 2.0, 0U, entries.size()});
entries.push_back({angular, u, 3.0, 0U, entries.size()});
const auto synthetic_tangent = Require(fesa::hht_internal::MakeSparse(
total, total, std::move(entries)));
reduced::AugmentedReducedSystem last_system{
synthetic_tangent, fesa::Vector(total), chart.p_columns.size(),
chart.z_columns.size(), fesa::Vector(total, 1.0), fesa::Vector(total, 1.0)};
fesa::Vector full_correction(total);
full_correction[angular] = 1.0;
last_system.rhs = last_system.tangent.Multiply(full_correction);
const auto baseline_selected = Require(reduced::SelectAugmentedSolve(
last_system, chart, true));
fesa::Vector selected_correction(baseline_selected.rhs.Size());
for (std::size_t i = 0U; i < selected_correction.Size(); ++i)
selected_correction[i] = full_correction[baseline_selected.full_indices[i]];
const LastSolve baseline{last_system, baseline_selected, selected_correction,
full_correction};
auto restricted_system = last_system;
restricted_system.rhs[u] = 0.0;
const auto restricted_selected = Require(reduced::SelectAugmentedSolve(
restricted_system, chart, true));
ASSERT_EQ(restricted_selected.full_indices, baseline_selected.full_indices);
const LastSolve restricted{restricted_system, restricted_selected,
selected_correction, full_correction};
auto full_defect = restricted_system.rhs;
full_defect.Axpy(-1.0, restricted_system.tangent.Multiply(full_correction));
ASSERT_NE(full_defect[u], 0.0);
fesa::MklPardisoTangentSolver solver;
fesa::Vector full_model(full_defect.Size());
Require(solver.FactorizeFresh(restricted_system.tangent));
Require(solver.SolveCorrection(full_defect, full_model));
Require(fesa::hht_internal::CheckLinearSolve(restricted_system.tangent,
full_defect, full_model));
const auto mapped_model = Require(reduced::MapAugmentedCorrection(
chart, restricted_system, full_model, cv, ca));
EXPECT_GT(mapped_model.coordinate.Norm(), 0.0);
const ArithmeticRadii radii{zero, zero, zero, zero};
GridEvidence baseline_evidence{h, h};
GridEvidence restricted_evidence{h, h};
RecordNoise(fixture, accepted, chart, operators, baseline, parameters,
radii, &solver, &baseline_evidence);
RecordNoise(fixture, accepted, chart, operators, restricted, parameters,
radii, &solver, &restricted_evidence);
double baseline_noise = 0.0;
double restricted_noise = 0.0;
for (std::size_t i = 0U; i < baseline_evidence.solve_noise.size(); ++i) {
baseline_noise += baseline_evidence.solve_noise[i];
restricted_noise += restricted_evidence.solve_noise[i];
}
EXPECT_GT(restricted_noise, baseline_noise);
}
GridEvidence::RecoveredAcceleration RecoverAcceleration(
const Fixture& fixture, const Assembly& assembly,
fesa::MklPardisoTangentSolver* solver, const bool manufactured) {
const auto nodes = assembly.rotations.size();
GridEvidence::RecoveredAcceleration result{assembly.frame.acceleration};
std::vector<double> weights(nodes);
std::vector<fesa::CooContribution> entries;
fesa::Vector rhs(nodes);
for (std::size_t row = 0; row < nodes; ++row) {
const auto& rotation = assembly.rotations[row];
fesa::Vector null(assembly.frame.acceleration.Size());
for (std::size_t c = 0; c < 3U; ++c)
null[6U * row + 3U + c] = rotation.drill_null[c];
const auto metric_null = assembly.drilling_metric.Multiply(null);
const double stiffness = null.Dot(metric_null);
if (!std::isfinite(stiffness) || !(stiffness > 0.0))
throw std::runtime_error{"C08 recovery requires positive null metric."};
weights[row] = std::sqrt(stiffness);
}
for (std::size_t row = 0; row < nodes; ++row) {
const auto& rotation = assembly.rotations[row];
const double raw = assembly.frame.hidden_acceleration_defect[row];
const double raw_scale =
assembly.frame.hidden_acceleration_defect_scale[row];
result.pre_hidden2 = std::max(result.pre_hidden2, std::abs(raw));
result.pre_hidden2_relative =
std::max(result.pre_hidden2_relative,
raw_scale == 0.0 ? std::abs(raw) : std::abs(raw) / raw_scale);
rhs[row] = -raw / weights[row];
for (std::size_t c = 0; c < 3U; ++c) {
const auto full = 6U * row + 3U + c;
const double force = assembly.frame.internal_force[full] -
assembly.frame.external_force[full];
for (std::size_t d = 0; d < 3U; ++d)
entries.push_back({row, row,
rotation.null_gradient(c, d) * force *
rotation.drill_null[d] / weights[row] /
weights[row],
0U, entries.size()});
for (std::size_t index = assembly.internal_tangent.RowOffsets()[full];
index < assembly.internal_tangent.RowOffsets()[full + 1U]; ++index) {
const auto column = assembly.internal_tangent.ColumnIndices()[index];
if (column % 6U < 3U) continue;
const auto column_node = column / 6U;
entries.push_back(
{row, column_node,
rotation.drill_null[c] *
assembly.internal_tangent.Values()[index] *
assembly.rotations[column_node].drill_null[column % 6U - 3U] /
weights[row] / weights[column_node],
0U, entries.size()});
}
}
}
const auto regularity =
Require(fesa::hht_internal::MakeSparse(nodes, nodes, std::move(entries)));
fesa::Vector scaled_eta(nodes);
Require(solver->FactorizeFresh(regularity));
Require(solver->SolveCorrection(rhs, scaled_eta));
Require(fesa::hht_internal::CheckLinearSolve(regularity, rhs, scaled_eta));
fesa::Vector delta(result.value.Size());
for (std::size_t node = 0; node < nodes; ++node)
for (std::size_t c = 0; c < 3U; ++c)
delta[6U * node + 3U + c] = assembly.rotations[node].drill_null[c] *
scaled_eta[node] / weights[node];
result.value.Axpy(1.0, delta);
const auto mass_delta = assembly.mass.Multiply(delta);
const double mass_scale = SparseNorm(assembly.mass) * delta.Norm();
result.mass_delta_a_relative =
mass_scale == 0.0 ? mass_delta.Norm() : mass_delta.Norm() / mass_scale;
if (manufactured) {
auto post = assembly.frame;
post.acceleration = result.value;
ManufacturedHidden(assembly, RigidForceRates(fixture, post.time), &post);
for (std::size_t row = 0; row < nodes; ++row) {
const double value = std::abs(post.hidden_acceleration_defect[row]);
const double scale = post.hidden_acceleration_defect_scale[row];
result.post_hidden2 = std::max(result.post_hidden2, value);
result.post_hidden2_relative = std::max(
result.post_hidden2_relative, scale == 0.0 ? value : value / scale);
}
return result;
}
for (std::size_t row = 0; row < nodes; ++row) {
fesa::Vector gradient(result.value.Size());
const auto& rotation = assembly.rotations[row];
for (std::size_t c = 0; c < 3U; ++c) {
const auto full = 6U * row + 3U + c;
const double force = assembly.frame.internal_force[full] -
assembly.frame.external_force[full];
for (std::size_t d = 0; d < 3U; ++d) {
const auto column = 6U * row + 3U + d;
gradient[column] += rotation.null_gradient(c, d) * force;
}
for (std::size_t index = assembly.internal_tangent.RowOffsets()[full];
index < assembly.internal_tangent.RowOffsets()[full + 1U]; ++index) {
const auto column = assembly.internal_tangent.ColumnIndices()[index];
gradient[column] +=
rotation.drill_null[c] * assembly.internal_tangent.Values()[index];
}
}
const double post =
assembly.hidden_second[row] + gradient.Dot(result.value);
double post_scale = assembly.hidden_second_scale[row];
for (std::size_t column = 0; column < gradient.Size(); ++column)
post_scale += std::abs(gradient[column] * result.value[column]);
result.post_hidden2 = std::max(result.post_hidden2, std::abs(post));
result.post_hidden2_relative = std::max(
result.post_hidden2_relative,
post_scale == 0.0 ? std::abs(post) : std::abs(post) / post_scale);
}
return result;
}
void CompleteOriginalConstraints(const Fixture& fixture, const Assembly& assembly,
const std::vector<std::size_t>& null_nodes,
fesa::MklPardisoSolver& positive,
fesa::MklPardisoTangentSolver& tangent,
Frame* frame, const double h, const char* stage,
const reduced::EmbeddingRoot* root = nullptr) {
const auto status = fesa::hht_internal::CompleteConstraintEvidence(
*fixture.domain, fixture.dofs, assembly, fixture.length, null_nodes,
positive, tangent, frame);
if (status.IsOk()) return;
std::ostringstream context;
context << std::setprecision(17) << "C08 h=" << h
<< ", increment=" << frame->increment_index << ", time=" << frame->time
<< ", stage=" << stage << ": " << Message(status);
if (root != nullptr)
context << "; graph_iterations=" << root->graph_iteration_count
<< ", graph_residual=" << root->graph_residual_infinity
<< ", graph_relative=" << root->graph_residual_relative
<< ", graph_correction=" << root->graph_correction_infinity;
std::cout << std::setprecision(17) << "C08_HIDDEN_Q=";
for (std::size_t i = 0U; i < frame->generalized_coordinates.Size(); ++i)
std::cout << frame->generalized_coordinates[i] << ',';
std::cout << "\n";
const auto chart = reduced::BuildFixedChart(fixture.dofs, assembly.rotations);
if (chart.HasValue()) {
const fesa::Vector zero(fixture.dofs.FullDofCount());
const auto operators = reduced::EvaluateConstraintOperators(
*fixture.domain, fixture.dofs, fixture.shells, assembly, chart.Value(), zero, zero);
if (operators.HasValue()) {
for (std::size_t row = 0U; row < chart.Value().null_nodes.size(); ++row) {
const auto node = chart.Value().null_nodes[row];
double projected = 0.0, contraction_scale = 0.0, residual_scale = 0.0;
for (std::size_t c = 0U; c < 3U; ++c) {
const auto full = 6U * node + 3U + c;
const double n = assembly.rotations[node].drill_null[c];
const double term = n * (frame->internal_force[full] - frame->external_force[full]);
projected += term;
contraction_scale += std::abs(term);
residual_scale += std::abs(n) * frame->residual_scale[full];
std::cout << std::setprecision(17) << "C08_HIDDEN_COMPONENT h=" << h
<< " increment=" << frame->increment_index << " node=" << node
<< " full=" << full << " n=" << n
<< " internal=" << frame->internal_force[full]
<< " external=" << frame->external_force[full]
<< " inertia=" << frame->inertia_force[full]
<< " q=" << frame->generalized_coordinates[full] << "\n";
}
std::cout << std::setprecision(17) << "C08_HIDDEN_FAILURE h=" << h
<< " increment=" << frame->increment_index << " time=" << frame->time
<< " stage=" << stage << " node=" << node
<< " raw_psi=" << operators.Value().rows[row].value
<< " raw_scale=" << operators.Value().rows[row].value_scale
<< " projected_psi=" << projected << " contraction_scale=" << contraction_scale
<< " residual_scale=" << residual_scale
<< " difference=" << projected - operators.Value().rows[row].value << "\n";
}
}
}
throw std::runtime_error{context.str()};
}
GridEvidence RunPlate(const Fixture& fixture, const double h,
const bool manufactured) {
GridEvidence evidence{h, manufactured ? 1.0 : kEndTime};
const auto p = Require(fesa::MakeHhtParameters(-0.05));
fesa::MklPardisoSolver positive;
fesa::MklPardisoTangentSolver tangent;
Frame frame = manufactured ? RigidOrbit(fixture, 0.0) : EmptyFrame(fixture);
const L3 translation{0.125L, -0.25L, 0.0625L};
const L3 omega{0.8L, 0.6L, 0.4L};
if (manufactured) {
frame.external_force = Integrate(fixture, frame).force;
} else {
for (std::size_t node = 0; node < fixture.domain->Nodes().size(); ++node) {
const auto x = Coordinates(fixture.domain->Nodes()[node]);
L3 velocity = Add(translation, Cross(omega, x));
velocity[2] += 0.02L * x[0] * x[1];
Store(velocity, &frame.velocity, 6U * node);
Store({0.8L, 0.6L, 0.0L}, &frame.velocity, 6U * node + 3U);
}
}
auto assembly = Evaluate(fixture, frame, h, p, true);
if (!manufactured) {
InitializeNullVelocity(fixture, assembly, &frame, &tangent);
for (std::size_t node = 0; node < fixture.domain->Nodes().size(); ++node)
EXPECT_NEAR(frame.velocity[6U * node + 5U], 0.4, 1.0e-12);
assembly = Evaluate(fixture, frame, h, p, true);
}
const auto null_nodes =
fesa::hht_internal::NullNodes(fixture.dofs, assembly.rotations);
if (!manufactured)
frame.acceleration = Require(fesa::hht_internal::InitializeAcceleration(
*fixture.domain, fixture.dofs, assembly, fixture.length, positive,
tangent));
frame.algorithmic_acceleration = frame.acceleration;
frame.time_integration_formulation =
fesa::DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
assembly = Evaluate(fixture, frame, h, p, true);
frame = assembly.frame;
// The fresh physical assembly certifies the initialized acceleration before
// it becomes frame-zero history; the initializer's private solve is separate.
for (const double residual : frame.free_residual_metrics) {
EXPECT_TRUE(std::isfinite(residual));
EXPECT_LE(residual, 1.0e-10);
}
if (manufactured)
CompleteManufacturedConstraints(fixture, assembly, null_nodes, &positive,
&tangent, &frame);
else
CompleteOriginalConstraints(fixture, assembly, null_nodes, positive, tangent,
&frame, h, "initial");
Require(fesa::hht_internal::CompleteEquilibrium(*fixture.domain, fixture.dofs,
assembly, &frame));
const auto initial_oracle = Integrate(fixture, frame);
const double energy0 = frame.kinetic_energy + frame.physical_strain_energy +
frame.drilling_energy;
EXPECT_GT(energy0, 0.0);
EXPECT_LE(std::abs(frame.kinetic_energy -
static_cast<double>(initial_oracle.kinetic)) /
energy0,
1.0e-12);
const auto initial_momentum = frame.linear_momentum;
const auto initial_angular_momentum = frame.angular_momentum;
evidence.history.push_back(frame);
evidence.recovered_acceleration.push_back({frame.acceleration});
ArithmeticRadii arithmetic_radii{fesa::Vector(frame.generalized_coordinates.Size()),
fesa::Vector(frame.generalized_coordinates.Size()),
fesa::Vector(frame.generalized_coordinates.Size()),
fesa::Vector(frame.generalized_coordinates.Size())};
const auto chart = Require(reduced::BuildFixedChart(fixture.dofs, assembly.rotations));
fesa::Vector private_p = Require(reduced::ProjectPhysical(
chart, frame.generalized_coordinates));
fesa::Vector private_v = Require(reduced::ProjectPhysical(chart, frame.velocity));
fesa::Vector private_a = Require(reduced::ProjectPhysical(chart, frame.acceleration));
fesa::Vector private_ar = private_a;
fesa::Vector private_p_radius = ProjectBasisRadii(
chart.p_columns, frame.generalized_coordinates, arithmetic_radii.coordinates);
fesa::Vector private_v_radius = ProjectBasisRadii(
chart.p_columns, frame.velocity, arithmetic_radii.velocity);
fesa::Vector private_a_radius = ProjectBasisRadii(
chart.p_columns, frame.acceleration, arithmetic_radii.acceleration);
fesa::Vector private_ar_radius = private_a_radius;
fesa::Vector seed = Require(reduced::ProjectAlgebraic(
chart, frame.generalized_coordinates));
const fesa::Vector zero(fixture.dofs.FullDofCount());
const auto force_rates = [&](const double time) {
return manufactured ? RigidForceRates(fixture, time)
: std::array<fesa::Vector, 2>{zero, zero};
};
const auto position_operators = [&](const Frame& endpoint,
const fesa::Vector& q) {
auto position = endpoint;
position.generalized_coordinates = q;
position.velocity = zero;
position.acceleration = zero;
position.algorithmic_acceleration = zero;
const auto position_assembly = Evaluate(fixture, position, h, p, false);
const auto rates = force_rates(endpoint.time);
return reduced::EvaluateConstraintOperators(*fixture.domain, fixture.dofs,
fixture.shells, position_assembly, chart, rates[0], rates[1]);
};
const auto root0 = Require(reduced::SolveEmbeddingRoot(chart, private_p, seed,
[&](const fesa::Vector& q) { return position_operators(frame, q); }, tangent));
const auto rates0 = Require(reduced::ReconstructPhysicalRates(
chart, root0, private_v, private_a, tangent));
for (std::size_t i = 0U; i < zero.Size(); ++i) {
EXPECT_DOUBLE_EQ(root0.q[i], frame.generalized_coordinates[i]);
EXPECT_DOUBLE_EQ(rates0.velocity[i], frame.velocity[i]);
}
// Preserve the original frame zero. Certify independently reconstructed a0
// by the original physical equation and N3/N4 gates, without a component
// absolute floor or silently projecting the stored initial state.
auto reconstructed_zero = frame;
reconstructed_zero.generalized_coordinates = root0.q;
reconstructed_zero.velocity = rates0.velocity;
reconstructed_zero.acceleration = rates0.acceleration;
reconstructed_zero.algorithmic_acceleration = rates0.acceleration;
const auto reconstructed_assembly = Evaluate(fixture, reconstructed_zero, h, p, true);
reconstructed_zero = reconstructed_assembly.frame;
if (manufactured)
CompleteManufacturedConstraints(fixture, reconstructed_assembly, null_nodes,
&positive, &tangent, &reconstructed_zero);
else
CompleteOriginalConstraints(fixture, reconstructed_assembly, null_nodes,
positive, tangent, &reconstructed_zero, h,
"reconstructed-initial");
Require(fesa::hht_internal::CompleteEquilibrium(*fixture.domain, fixture.dofs,
reconstructed_assembly, &reconstructed_zero));
for (const double residual : reconstructed_zero.free_residual_metrics)
EXPECT_LE(residual, 1.0e-10);
Require(reduced::CheckGraphRegularity(assembly, chart, root0.operators, tangent));
const auto increments = static_cast<std::uint32_t>(evidence.end_time / h);
for (std::uint32_t increment = 1U; increment <= increments; ++increment) {
const Frame old = frame;
// FB-08 is private-coordinate history. Basis labels must never be
// reinterpreted as full indices or be fed through a full-vector predictor.
fesa::HhtPredictor predictor{fesa::Vector(private_p.Size()),
fesa::Vector(private_p.Size())};
fesa::Vector predictor_coordinate_radius(private_p.Size());
fesa::Vector predictor_velocity_radius(private_p.Size());
for (std::size_t i = 0U; i < private_p.Size(); ++i) {
const double velocity_term = h * private_v[i];
const double h2 = h * h;
const double acceleration_term = h2 * (0.5 - p.beta) * private_ar[i];
predictor.coordinates[i] = private_p[i] + velocity_term + acceleration_term;
predictor.velocity[i] = private_v[i] + h * (1.0 - p.gamma) * private_ar[i];
const double velocity_radius = ProductRadius(h, 0.0,
private_v[i], private_v_radius[i]);
const double h2_radius = ProductRadius(h, 0.0, h, 0.0);
const double acceleration_radius = ProductRadius(
h2 * (0.5 - p.beta),
ProductRadius(h2, h2_radius, 0.5 - p.beta,
RoundoffRadius(0.5 - p.beta)),
private_ar[i], private_ar_radius[i]);
predictor_coordinate_radius[i] = AddRadius(predictor.coordinates[i],
AddRadius(private_p[i] + velocity_term, private_p_radius[i], velocity_radius),
acceleration_radius);
const double rate_factor = h * (1.0 - p.gamma);
predictor_velocity_radius[i] = AddRadius(predictor.velocity[i],
private_v_radius[i], ProductRadius(rate_factor,
ProductRadius(h, 0.0, 1.0 - p.gamma,
RoundoffRadius(1.0 - p.gamma)),
private_ar[i], private_ar_radius[i]));
}
frame.is_initial = false;
frame.frame_index = increment;
frame.increment_index = increment;
frame.time = static_cast<double>(increment) * h;
frame.time_integration_formulation =
fesa::DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
if (manufactured)
frame.external_force = Integrate(fixture, RigidOrbit(fixture, frame.time)).force;
bool correction_pass = true;
// These are the last *applied* translation-channel corrections. They
// deliberately remain outside the all-channel acceptance flag: the
// approved restricted solve is eligible only after this channel itself
// has passed its original four mapped-update checks.
std::array<double, 4U> translation_corrections{};
bool translation_private_algorithmic_pass = true;
const auto private_algorithmic_equal = [](const double actual,
const double reduced_value) {
const double defect = std::abs(actual - reduced_value);
const double scale = std::abs(reduced_value);
return std::isfinite(defect) && std::isfinite(scale) &&
(scale == 0.0 ? defect == 0.0 : defect / scale <= 1.0e-12);
};
bool converged = false;
std::optional<LastSolve> last;
fesa::Vector ar(chart.p_columns.size());
fesa::Vector ar_radius(chart.p_columns.size());
fesa::Vector candidate_p(chart.p_columns.size());
fesa::Vector candidate_p_radius(chart.p_columns.size());
fesa::Vector candidate_p_low(chart.p_columns.size());
fesa::Vector candidate_p_pair_radius(chart.p_columns.size());
fesa::Vector chosen_start_p(chart.p_columns.size());
fesa::Vector last_p_before_update(chart.p_columns.size());
fesa::Vector last_requested_delta(chart.p_columns.size());
fesa::Vector addition_low_sum(chart.p_columns.size());
fesa::Vector requested_sum(chart.p_columns.size());
fesa::Vector requested_compensation(chart.p_columns.size());
fesa::Vector requested_absolute_sum(chart.p_columns.size());
bool copy_translation_rates = false;
fesa::Vector retained_velocity(chart.p_columns.size());
fesa::Vector retained_acceleration(chart.p_columns.size());
fesa::Vector retained_velocity_radius(chart.p_columns.size());
fesa::Vector retained_acceleration_radius(chart.p_columns.size());
const auto record_requested_increment = [&](const std::size_t i, const double delta) {
const double previous = requested_sum[i];
const double next = previous + delta;
requested_compensation[i] += std::abs(previous) >= std::abs(delta)
? (previous - next) + delta : (delta - next) + previous;
requested_sum[i] = next;
if (delta != 0.0)
requested_absolute_sum[i] = UpSum(requested_absolute_sum[i], std::abs(delta));
};
for (std::size_t i = 0U; i < candidate_p.Size(); ++i) {
candidate_p[i] = predictor.coordinates[i] + p.beta * h * h * ar[i];
chosen_start_p[i] = candidate_p[i];
const double velocity_term = h * private_v[i];
const double acceleration_term = h * h * (0.5 - p.beta) * private_ar[i];
const double first_sum = private_p[i] + velocity_term;
addition_low_sum[i] = AdditionLowPart(private_p[i], velocity_term, first_sum) +
AdditionLowPart(first_sum, acceleration_term, predictor.coordinates[i]);
candidate_p_low[i] = addition_low_sum[i];
record_requested_increment(i, h * private_v[i]);
record_requested_increment(i, h * h * (0.5 - p.beta) * private_ar[i]);
candidate_p_radius[i] = AddRadius(candidate_p[i],
predictor_coordinate_radius[i], ProductRadius(p.beta * h * h,
HhtCoordinateFactorRadius(p, h), ar[i], ar_radius[i]));
candidate_p_pair_radius[i] = UpSum(candidate_p_radius[i],
std::abs(candidate_p_low[i]));
}
ArithmeticRadii trial_radii{zero, zero, zero, zero};
struct Trial {
Assembly assembly;
reduced::EmbeddingRoot root;
fesa::Vector vp;
fesa::Vector ap;
fesa::Vector ar;
};
const auto evaluate_trial = [&](const fesa::Vector& trial_ar,
const fesa::Vector& physical_p) {
fesa::Vector vp(chart.p_columns.size());
fesa::Vector ap(chart.p_columns.size());
for (std::size_t i = 0U; i < physical_p.Size(); ++i) {
if (copy_translation_rates && reduced::PhysicalCoordinateChannel(chart, i) == 0U) {
vp[i] = retained_velocity[i];
ap[i] = retained_acceleration[i];
} else {
vp[i] = predictor.velocity[i] + p.gamma * h * trial_ar[i];
ap[i] = (trial_ar[i] + p.alpha * private_a[i]) / (1.0 + p.alpha);
}
}
auto root = Require(reduced::SolveEmbeddingRoot(chart, physical_p, seed,
[&](const fesa::Vector& q) { return position_operators(frame, q); }, tangent));
const auto rates = Require(reduced::ReconstructPhysicalRates(
chart, root, vp, ap, tangent));
auto candidate = frame;
candidate.generalized_coordinates = root.q;
candidate.velocity = rates.velocity;
candidate.acceleration = rates.acceleration;
for (std::size_t i = 0U; i < zero.Size(); ++i)
candidate.algorithmic_acceleration[i] =
(1.0 + p.alpha) * candidate.acceleration[i] - p.alpha * old.acceleration[i];
return Trial{Evaluate(fixture, candidate, h, p, true), std::move(root),
std::move(vp), std::move(ap), trial_ar};
};
auto trial = evaluate_trial(ar, candidate_p);
bool same_start = true;
fesa::Vector old_ar(ar.Size());
for (std::size_t i = 0U; i < ar.Size(); ++i) {
same_start = same_start && private_p[i] == predictor.coordinates[i];
old_ar[i] = (private_p[i] - predictor.coordinates[i]) / (p.beta * h * h);
}
if (!same_start) {
// Both candidates are lifted at the new endpoint time; cache the winner.
const auto old_trial = evaluate_trial(old_ar, private_p);
const auto residual_norm = [&](const Assembly& value) {
double norm = 0.0;
for (const auto full : fixture.dofs.FreeDofs())
norm = std::max(norm, std::abs(value.frame.residual[full]) *
(full % 6U < 3U ? fixture.length : 1.0));
if (!std::isfinite(norm)) throw std::runtime_error{"C08 nonfinite start residual."};
return norm;
};
if (residual_norm(old_trial.assembly) < residual_norm(trial.assembly)) {
trial = old_trial;
ar = old_ar;
candidate_p = private_p;
chosen_start_p = private_p;
candidate_p_low = fesa::Vector(ar.Size());
addition_low_sum = fesa::Vector(ar.Size());
candidate_p_radius = private_p_radius;
for (std::size_t i = 0U; i < ar.Size(); ++i)
candidate_p_pair_radius[i] = candidate_p_radius[i];
// The selected old-p object has exact zero initial displacement.
requested_sum = fesa::Vector(ar.Size());
requested_compensation = fesa::Vector(ar.Size());
requested_absolute_sum = fesa::Vector(ar.Size());
for (std::size_t i = 0U; i < ar.Size(); ++i) {
const double numerator = private_p[i] - predictor.coordinates[i];
ar_radius[i] = QuotientRadius(numerator,
AddRadius(numerator, private_p_radius[i],
predictor_coordinate_radius[i]),
p.beta * h * h, HhtCoordinateFactorRadius(p, h));
}
}
}
for (std::uint32_t iteration = 0U; iteration <= 100U; ++iteration) {
if (iteration > 0U) trial = evaluate_trial(ar, candidate_p);
assembly = trial.assembly;
frame = assembly.frame;
const auto time_rates = force_rates(frame.time);
const auto operators = Require(reduced::EvaluateConstraintOperators(
*fixture.domain, fixture.dofs, fixture.shells, assembly, chart,
time_rates[0], time_rates[1]));
// The trial radii begin with the immutable sparse p basis. The graph
// indicator appends z/vz/az uncertainty after its frozen endpoint solve.
fesa::Vector vp_radius(chart.p_columns.size());
fesa::Vector ap_radius(chart.p_columns.size());
for (std::size_t i = 0U; i < ar.Size(); ++i) {
if (copy_translation_rates &&
reduced::PhysicalCoordinateChannel(chart, i) == 0U) {
vp_radius[i] = retained_velocity_radius[i];
ap_radius[i] = retained_acceleration_radius[i];
continue;
}
vp_radius[i] = AddRadius(trial.vp[i], predictor_velocity_radius[i],
ProductRadius(p.gamma * h, ProductRadius(p.gamma, 0.0, h, 0.0),
ar[i], ar_radius[i]));
const double numerator = ar[i] + p.alpha * private_a[i];
ap_radius[i] = QuotientRadius(numerator,
AddRadius(numerator, ar_radius[i], ProductRadius(p.alpha, 0.0,
private_a[i], private_a_radius[i])),
1.0 + p.alpha, RoundoffRadius(1.0 + p.alpha));
}
trial_radii = {LiftBasisRadii(chart.p_columns, candidate_p,
candidate_p_radius, chart.full_dof_count),
LiftBasisRadii(chart.p_columns, trial.vp, vp_radius,
chart.full_dof_count),
LiftBasisRadii(chart.p_columns, trial.ap, ap_radius,
chart.full_dof_count),
LiftBasisRadii(chart.p_columns, ar, ar_radius,
chart.full_dof_count)};
if (correction_pass && frame.free_residual_metrics[0] <= 1.0e-10 &&
frame.free_residual_metrics[1] <= 1.0e-10) {
if (manufactured)
CompleteManufacturedConstraints(fixture, assembly, null_nodes,
&positive, &tangent, &frame);
else
CompleteOriginalConstraints(fixture, assembly, null_nodes, positive,
tangent, &frame, h, "accepted", &trial.root);
Require(fesa::hht_internal::CompleteEquilibrium(*fixture.domain,
fixture.dofs, assembly, &frame));
Require(reduced::CheckGraphRegularity(assembly, chart, operators, tangent));
if (!last) throw std::runtime_error{"C08 nontrivial step lacks N7 last solve."};
const auto full_indicator = GraphArithmeticIndicator(frame, old, chart,
operators, trial_radii, arithmetic_radii, p, &tangent);
RecordNoise(fixture, assembly, chart, operators, *last, p, full_indicator,
&tangent, &evidence);
auto recovery_assembly = assembly;
recovery_assembly.frame = frame;
evidence.recovered_acceleration.push_back(RecoverAcceleration(
fixture, recovery_assembly, &tangent, manufactured));
frame.iteration_count = iteration;
const auto update_equal = [](const double actual,
const std::initializer_list<double> terms) {
double value = 0.0;
double scale = 0.0;
for (const double term : terms) {
value += term;
scale += std::abs(term);
}
const double defect = std::abs(actual - value);
return std::isfinite(defect) && std::isfinite(scale) &&
(scale == 0.0 ? defect == 0.0 : defect / scale <= 1.0e-12);
};
struct UpdateTrace {
double ratio = 0.0;
double actual = 0.0;
double expected = 0.0;
double scale = 0.0;
std::size_t full = 0U;
double signed_sum = 0.0;
double compensation = 0.0;
};
std::array<UpdateTrace, 3> update_trace{};
const auto trace_update = [&](const std::size_t check, const std::size_t full,
const double actual,
const std::initializer_list<double> terms) {
double expected = 0.0;
double scale = 0.0;
for (const double term : terms) {
expected += term;
scale += std::abs(term);
}
const double defect = std::abs(actual - expected);
const double ratio = scale == 0.0
? (defect == 0.0 ? 0.0 : std::numeric_limits<double>::infinity())
: defect / scale;
if (ratio >= update_trace[check].ratio)
update_trace[check] = {ratio, actual, expected, scale, full};
return update_equal(actual, terms);
};
for (std::size_t i = 0U; i < ar.Size(); ++i) {
const auto full = chart.p_dofs[i];
SCOPED_TRACE("increment=" + std::to_string(increment) + ", full=" + std::to_string(full));
EXPECT_TRUE(update_equal(trial.root.p[i],
{predictor.coordinates[i], p.beta * h * h * ar[i]}));
EXPECT_TRUE(update_equal(trial.vp[i],
{predictor.velocity[i], p.gamma * h * ar[i]}));
trace_update(0U, full, trial.root.p[i] - private_p[i],
{h * private_v[i], h * h * (0.5 - p.beta) * private_ar[i],
p.beta * h * h * ar[i]});
const double velocity_term = h * private_v[i];
const double old_rate_term = h * h * (0.5 - p.beta) * private_ar[i];
const double new_rate_term = p.beta * h * h * ar[i];
const auto whole_pair = reduced::CheckPairIncrement(trial.root.p[i],
candidate_p_low[i], private_p[i],
{velocity_term, old_rate_term, new_rate_term},
std::abs(velocity_term) + std::abs(old_rate_term) + std::abs(new_rate_term));
EXPECT_TRUE(whole_pair.storage_pass);
EXPECT_TRUE(whole_pair.arithmetic_pass) << whole_pair.ratio;
const double stored_increment = requested_sum[i] + requested_compensation[i];
const double actual_increment = trial.root.p[i] - private_p[i];
const double trace_defect = std::abs(actual_increment - stored_increment);
const double trace_scale = requested_absolute_sum[i];
const auto requested_pair = reduced::CheckPairIncrement(trial.root.p[i],
candidate_p_low[i], private_p[i],
{requested_sum[i], requested_compensation[i]}, trace_scale);
const double trace_ratio = trace_scale == 0.0
? (trace_defect == 0.0 ? 0.0 : std::numeric_limits<double>::infinity())
: trace_defect / trace_scale;
if (!(std::isfinite(trace_ratio) && trace_ratio <= 1.0e-12))
std::cout << std::setprecision(17) << "C08_POSITION_REPRESENTATION_DIAGNOSTIC h=" << h
<< " increment=" << increment << " full=" << full
<< " old_p=" << private_p[i] << " start_p=" << chosen_start_p[i]
<< " p=" << trial.root.p[i] << " actual=" << actual_increment
<< " expected=" << stored_increment << " signed_sum=" << requested_sum[i]
<< " compensation=" << requested_compensation[i] << " scale=" << trace_scale
<< " ratio=" << trace_ratio << " last_before=" << last_p_before_update[i]
<< " last_delta=" << last_requested_delta[i]
<< " addition_low_sum=" << addition_low_sum[i]
<< " candidate_low=" << candidate_p_low[i]
<< " pair_ratio=" << requested_pair.ratio
<< " pair_storage=" << requested_pair.storage_pass
<< " subtraction_low=" << AdditionLowPart(trial.root.p[i], -private_p[i], actual_increment)
<< "\n";
EXPECT_TRUE(requested_pair.storage_pass);
EXPECT_TRUE(requested_pair.arithmetic_pass) << requested_pair.ratio;
if (trace_ratio >= update_trace[1U].ratio)
update_trace[1U] = {trace_ratio, actual_increment, stored_increment, trace_scale, full,
requested_sum[i], requested_compensation[i]};
// This subtraction is diagnostic only; N3 requires the absolute
// velocity update and the resolved position increment.
trace_update(2U, full, trial.vp[i] - private_v[i],
{h * (1.0 - p.gamma) * private_ar[i], p.gamma * h * ar[i]});
EXPECT_TRUE(update_equal((1.0 + p.alpha) * trial.ap[i],
{ar[i], p.alpha * private_a[i]}));
}
if (increment <= 5U) {
for (std::size_t check = 0U; check < update_trace.size(); ++check) {
const auto& value = update_trace[check];
std::cout << std::setprecision(17) << "C08_RESOLVED_TRACE h=" << h
<< " increment=" << increment << " check=" << check
<< " full=" << value.full << " ratio=" << value.ratio
<< " actual=" << value.actual << " expected=" << value.expected
<< " scale=" << value.scale << " signed_sum=" << value.signed_sum
<< " compensation=" << value.compensation << "\n";
}
}
for (std::size_t i = 0U; i < zero.Size(); ++i)
EXPECT_DOUBLE_EQ(frame.algorithmic_acceleration[i],
(1.0 + p.alpha) * frame.acceleration[i] - p.alpha * old.acceleration[i]);
private_p = trial.root.p;
private_v = trial.vp;
private_a = trial.ap;
private_ar = ar;
private_p_radius = candidate_p_radius;
private_v_radius = vp_radius;
private_a_radius = ap_radius;
private_ar_radius = ar_radius;
seed = trial.root.z;
arithmetic_radii = full_indicator;
// Private carried-Ar remains a sparse p-coordinate history. Its full
// diagnostic lift is already represented by the frozen graph result;
// do not overwrite a plane support with a canonical label index.
converged = true;
break;
}
if (iteration == 100U) break;
const double cv = p.gamma / (p.beta * h);
const double ca = 1.0 / ((1.0 + p.alpha) * p.beta * h * h);
auto system = Require(reduced::AssembleAugmentedReducedSystem(
assembly, chart, operators, cv, ca, fixture.length, h));
const bool angular_only = reduced::ShouldRefineAngular(
chart, frame.free_residual_metrics, translation_corrections,
translation_private_algorithmic_pass);
auto selected = Require(reduced::SelectAugmentedSolve(system, chart,
angular_only));
fesa::Vector selected_solution(selected.rhs.Size());
Require(tangent.FactorizeFresh(selected.tangent));
Require(tangent.SolveCorrection(selected.rhs, selected_solution));
Require(fesa::hht_internal::CheckLinearSolve(selected.tangent,
selected.rhs,
selected_solution));
auto solution = Require(reduced::EmbedAugmentedSolution(
selected, selected_solution, system.rhs.Size()));
const auto correction = Require(reduced::MapAugmentedCorrection(
chart, system, solution, cv, ca));
correction_pass = true;
std::array<double, 4U> next_translation_corrections{};
for (const auto full : fixture.dofs.FreeDofs()) {
const double scale = full % 6U < 3U ? fixture.length : 1.0;
const std::array<double, 4U> values{
correction.coordinate[full], h * correction.velocity[full],
h * h * correction.acceleration[full],
h * h * (1.0 + p.alpha) * correction.acceleration[full]};
for (std::size_t rate = 0U; rate < values.size(); ++rate) {
const double ratio = std::abs(values[rate]) / scale;
correction_pass = correction_pass && ratio <= 1.0e-10;
if (full % 6U < 3U) {
if (!std::isfinite(ratio))
next_translation_corrections[rate] =
std::numeric_limits<double>::infinity();
else
next_translation_corrections[rate] = std::max(
next_translation_corrections[rate], ratio);
}
}
}
for (std::size_t i = 0U; i < ar.Size(); ++i) {
const double delta = correction.p[i] / (p.beta * h * h);
const double scale = reduced::PhysicalCoordinateChannel(chart, i) == 0U ? fixture.length : 1.0;
const double algorithmic_ratio = std::abs(h * h * delta) / scale;
correction_pass = correction_pass && algorithmic_ratio <= 1.0e-10;
// Preserve the physical Newton increment even when pp + beta*h*h*Ar
// cancels large terms. Ar retains its own equivalent HHT recurrence.
if (selected.angular_only && reduced::PhysicalCoordinateChannel(chart, i) == 0U)
continue;
record_requested_increment(i, correction.p[i]);
last_p_before_update[i] = candidate_p[i];
last_requested_delta[i] = correction.p[i];
const double raw_sum = candidate_p[i] + correction.p[i];
addition_low_sum[i] += AdditionLowPart(candidate_p[i], correction.p[i], raw_sum);
AdvanceCoordinate(correction.p[i], &candidate_p[i], &candidate_p_low[i],
&candidate_p_pair_radius[i]);
candidate_p_radius[i] = UpSum(candidate_p_pair_radius[i],
std::abs(candidate_p_low[i]));
ar[i] += delta;
ar_radius[i] = AddRadius(ar[i], ar_radius[i], QuotientRadius(
correction.p[i], 0.0, p.beta * h * h, HhtCoordinateFactorRadius(p, h)));
}
translation_corrections = next_translation_corrections;
// Retain the original private k*delta_ap=delta_Ar identity. The
// sparse Lp projection below is an additional basis-lift evidence, not
// a replacement for this recurrence check.
const double private_acceleration_rate =
1.0 / ((1.0 + p.alpha) * p.beta * h * h);
fesa::Vector delta_algorithmic_acceleration = correction.acceleration;
delta_algorithmic_acceleration.Scale(1.0 + p.alpha);
const auto projected_delta_algorithmic = Require(reduced::ProjectPhysical(
chart, delta_algorithmic_acceleration));
for (std::size_t i = 0U; i < ar.Size(); ++i) {
const double delta_ar = correction.p[i] / (p.beta * h * h);
const double private_delta_a = private_acceleration_rate * correction.p[i];
EXPECT_TRUE(private_algorithmic_equal((1.0 + p.alpha) * private_delta_a,
delta_ar));
double lifted = 0.0;
double lifted_scale = std::abs(delta_ar);
for (const auto& entry : chart.p_columns[i].support) {
const double term =
entry.value * delta_algorithmic_acceleration[entry.dof];
lifted += term;
lifted_scale += std::abs(term);
}
const double lifted_defect = std::abs(lifted - delta_ar);
const bool lifted_pass = std::isfinite(lifted_defect) &&
std::isfinite(lifted_scale) &&
(lifted_scale == 0.0 ? lifted_defect == 0.0
: lifted_defect / lifted_scale <= 1.0e-12);
EXPECT_TRUE(lifted_pass);
// This computed projection is diagnostic only: it includes rounded
// plane/algebraic leakage and must not replace private FB-08 history.
EXPECT_TRUE(std::isfinite(projected_delta_algorithmic[i]));
if (reduced::PhysicalCoordinateChannel(chart, i) != 0U) continue;
const double ratio = std::abs(h * h * delta_ar) / fixture.length;
translation_private_algorithmic_pass =
translation_private_algorithmic_pass && std::isfinite(ratio) &&
ratio <= 1.0e-10 && private_algorithmic_equal(
(1.0 + p.alpha) * private_delta_a, delta_ar);
}
copy_translation_rates = selected.angular_only;
if (copy_translation_rates) {
retained_velocity = trial.vp;
retained_acceleration = trial.ap;
retained_velocity_radius = vp_radius;
retained_acceleration_radius = ap_radius;
}
seed = trial.root.z;
for (std::size_t i = 0U; i < seed.Size(); ++i)
seed[i] += correction.z[i];
last.emplace(LastSolve{std::move(system), std::move(selected),
std::move(selected_solution), std::move(solution)});
}
if (!converged)
throw std::runtime_error{"C08 reduced Newton exhausted 100 corrections at h=" +
std::to_string(h) + ", increment=" + std::to_string(increment)};
const auto physical_oracle = Integrate(fixture, frame);
EXPECT_LE(std::abs(frame.kinetic_energy -
static_cast<double>(physical_oracle.kinetic)) / energy0, 1.0e-10);
EXPECT_LE(static_cast<double>(Norm(Add(physical_oracle.momentum,
Scale(L3{frame.linear_momentum[0], frame.linear_momentum[1],
frame.linear_momentum[2]}, -1.0L)))) /
static_cast<double>(initial_oracle.momentum_scale), 1.0e-10);
EXPECT_LE(static_cast<double>(Norm(Add(physical_oracle.angular_momentum,
Scale(L3{frame.angular_momentum[0], frame.angular_momentum[1],
frame.angular_momentum[2]}, -1.0L)))) /
static_cast<double>(initial_oracle.angular_momentum_scale), 1.0e-10);
const double energy = frame.kinetic_energy + frame.physical_strain_energy +
frame.drilling_energy;
if (!manufactured)
evidence.energy_error =
std::max(evidence.energy_error, std::abs(energy - energy0) / energy0);
double dp = 0.0;
double dl = 0.0;
for (std::size_t c = 0; c < 3; ++c) {
dp = std::hypot(dp, frame.linear_momentum[c] - initial_momentum[c]);
dl = std::hypot(dl,
frame.angular_momentum[c] - initial_angular_momentum[c]);
}
if (!manufactured) {
evidence.momentum_error =
std::max(evidence.momentum_error,
dp / static_cast<double>(initial_oracle.momentum_scale));
evidence.angular_momentum_error = std::max(
evidence.angular_momentum_error,
dl / static_cast<double>(initial_oracle.angular_momentum_scale));
}
for (std::size_t node = 0; node < fixture.domain->Nodes().size(); ++node)
evidence.maximum_rotation = std::max(
evidence.maximum_rotation,
static_cast<double>(
Norm(Triple(frame.generalized_coordinates, 6U * node + 3U))));
for (std::size_t node = 0; node < fixture.domain->Nodes().size(); ++node)
for (std::size_t channel = 0; channel < 2U; ++channel) {
const auto offset = 6U * node + 3U * channel;
const double scale = channel == 0U ? fixture.length : 1.0;
evidence.algorithmic_acceleration_gap = std::max(
evidence.algorithmic_acceleration_gap,
evidence.end_time * evidence.end_time / scale *
static_cast<double>(Norm(
Add(Triple(frame.algorithmic_acceleration, offset),
Scale(Triple(frame.acceleration, offset), -1.0L)))));
}
for (std::size_t i = 0; i < frame.hidden_constraint.Size(); ++i) {
if (frame.hidden_constraint_scale[i] == 0.0)
EXPECT_DOUBLE_EQ(frame.hidden_constraint[i], 0.0);
else
EXPECT_LE(std::abs(frame.hidden_constraint[i]) /
frame.hidden_constraint_scale[i],
1.0e-10);
const double vscale = frame.hidden_velocity_defect_scale[i];
const double ascale = frame.hidden_acceleration_defect_scale[i];
if (vscale > 0.0)
evidence.hidden_velocity =
std::max(evidence.hidden_velocity,
std::abs(frame.hidden_velocity_defect[i]) / vscale);
else
EXPECT_DOUBLE_EQ(frame.hidden_velocity_defect[i], 0.0);
if (ascale > 0.0)
evidence.hidden_acceleration =
std::max(evidence.hidden_acceleration,
std::abs(frame.hidden_acceleration_defect[i]) / ascale);
else
EXPECT_DOUBLE_EQ(frame.hidden_acceleration_defect[i], 0.0);
}
evidence.history.push_back(frame);
}
std::cout << std::setprecision(17) << (manufactured ? "C08a" : "C08b")
<< " h=" << h;
if (!manufactured)
std::cout << " energy=" << evidence.energy_error
<< " P=" << evidence.momentum_error
<< " L=" << evidence.angular_momentum_error;
std::cout << " phi_max=" << evidence.maximum_rotation
<< " a_A_gap=" << evidence.algorithmic_acceleration_gap
<< " hidden_v=" << evidence.hidden_velocity
<< " hidden_a=" << evidence.hidden_acceleration << " solve_noise=";
for (const double value : evidence.solve_noise) std::cout << value << ',';
std::cout << " arithmetic_scope=frozen-operator-first-order-indicator round_noise=";
for (const double value : evidence.arithmetic_noise)
std::cout << value << ',';
std::cout << " selector_history_radii=";
for (const double value : evidence.selector_history_arithmetic_noise)
std::cout << value << ',';
std::cout << " public_A_indicator=";
for (const double value : evidence.full_filter_arithmetic_noise)
std::cout << value << ',';
std::cout << '\n';
return evidence;
}
std::array<double, 6> Differences(const GridEvidence& coarse,
const GridEvidence& fine,
const double length) {
std::array<double, 6> error{};
for (std::size_t frame = 0; frame < coarse.history.size(); ++frame) {
const auto& a = coarse.history[frame];
const auto& b = fine.history[static_cast<std::size_t>(
std::llround(coarse.h / fine.h)) * frame];
const std::array<const fesa::Vector*, 3> first{
&a.generalized_coordinates, &a.velocity, &a.acceleration};
const std::array<const fesa::Vector*, 3> second{
&b.generalized_coordinates, &b.velocity, &b.acceleration};
for (std::size_t node = 0; node < a.nodal_internal_order.size(); ++node) {
for (std::size_t channel = 0; channel < 2; ++channel) {
const auto offset = 6U * node + 3U * channel;
for (std::size_t rate = 0; rate < 3; ++rate) {
const double normalization =
(rate == 0 ? 1.0
: rate == 1 ? coarse.end_time
: coarse.end_time * coarse.end_time) /
(channel == 0U ? length : 1.0);
const double difference = static_cast<double>(
Norm(Add(Triple(*first[rate], offset),
Scale(Triple(*second[rate], offset), -1.0L))));
error[2U * rate + channel] =
std::max(error[2U * rate + channel], normalization * difference);
}
}
}
}
return error;
}
std::array<double, 6> FrameError(const Frame& actual, const Frame& exact,
const double length, const double end_time) {
std::array<double, 6> error{};
const std::array<const fesa::Vector*, 3> first{
&actual.generalized_coordinates, &actual.velocity, &actual.acceleration};
const std::array<const fesa::Vector*, 3> second{
&exact.generalized_coordinates, &exact.velocity, &exact.acceleration};
for (std::size_t node = 0; node < actual.generalized_coordinates.Size() / 6U;
++node) {
for (std::size_t channel = 0; channel < 2U; ++channel) {
const auto offset = 6U * node + 3U * channel;
for (std::size_t rate = 0; rate < 3U; ++rate) {
const double factor = (rate == 0U ? 1.0
: rate == 1U ? end_time
: end_time * end_time) /
(channel == 0U ? length : 1.0);
error[2U * rate + channel] = std::max(
error[2U * rate + channel],
factor * static_cast<double>(Norm(
Add(Triple(*first[rate], offset),
Scale(Triple(*second[rate], offset), -1.0L)))));
}
}
}
return error;
}
std::array<double, 6> RecoveredFrameError(
const Frame& actual, const fesa::Vector& recovered_acceleration,
const Frame& exact, const double length, const double end_time) {
auto recovered = actual;
recovered.acceleration = recovered_acceleration;
return FrameError(recovered, exact, length, end_time);
}
std::array<double, 6> RecoveredDifferences(const GridEvidence& coarse,
const GridEvidence& fine,
const double length) {
std::array<double, 6> error{};
for (std::size_t frame = 0; frame < coarse.history.size(); ++frame) {
const auto& a = coarse.history[frame];
const auto& b = fine.history[static_cast<std::size_t>(
std::llround(coarse.h / fine.h)) * frame];
const std::array<const fesa::Vector*, 3> first{
&a.generalized_coordinates, &a.velocity,
&coarse.recovered_acceleration[frame].value};
const std::array<const fesa::Vector*, 3> second{
&b.generalized_coordinates, &b.velocity,
&fine.recovered_acceleration[static_cast<std::size_t>(
std::llround(coarse.h / fine.h)) * frame].value};
for (std::size_t node = 0; node < a.nodal_internal_order.size(); ++node) {
for (std::size_t channel = 0; channel < 2; ++channel) {
const auto offset = 6U * node + 3U * channel;
const double scale = channel == 0U ? length : 1.0;
for (std::size_t rate = 0; rate < 3; ++rate) {
const double normalization =
(rate == 0U ? 1.0
: rate == 1U ? coarse.end_time
: coarse.end_time * coarse.end_time) /
scale;
error[2U * rate + channel] = std::max(
error[2U * rate + channel],
normalization *
static_cast<double>(
Norm(Add(Triple(*first[rate], offset),
Scale(Triple(*second[rate], offset), -1.0L)))));
}
}
}
}
return error;
}
std::array<double, 2> AccelerationSplit(const Frame& basis,
const fesa::Vector& first,
const fesa::Vector& second,
const double end_time) {
const auto dofs = basis.generalized_coordinates.Size();
if (dofs % 6U != 0U || basis.velocity.Size() != dofs ||
basis.acceleration.Size() != dofs || first.Size() != dofs ||
second.Size() != dofs) {
throw std::runtime_error{
"C08 acceleration split requires matching nodal vectors."};
}
std::array<double, 2> split{};
for (std::size_t node = 0; node < dofs / 6U; ++node) {
const auto offset = 6U * node + 3U;
auto vector3 = [](const L3& value) {
return fesa::Vector3{static_cast<double>(value[0]),
static_cast<double>(value[1]),
static_cast<double>(value[2])};
};
const auto rotation = Require(fesa::EvaluateDynamicRotation(
vector3(Triple(basis.generalized_coordinates, offset)), {0.0, 0.0, 1.0},
vector3(Triple(basis.velocity, offset)),
vector3(Triple(basis.acceleration, offset))));
const L3 null{rotation.drill_null[0], rotation.drill_null[1],
rotation.drill_null[2]};
const L3 difference =
Add(Triple(first, offset), Scale(Triple(second, offset), -1.0L));
split[0] = std::max(
split[0], end_time * end_time *
static_cast<double>(std::abs(Dot(null, difference))));
split[1] = std::max(split[1],
end_time * end_time *
static_cast<double>(Norm(Cross(null, difference))));
}
return split;
}
TEST(HhtShellPhysics, ReducedManufacturedControllerKeepsExactInitialOrbit) {
const auto fixture = MakeFixture(1U);
const auto grid = RunPlate(fixture, 1.0 / 64.0, true);
ASSERT_EQ(grid.history.size(), 65U);
const auto exact = RigidOrbit(fixture, 0.0);
for (std::size_t i = 0U; i < exact.generalized_coordinates.Size(); ++i) {
EXPECT_DOUBLE_EQ(grid.history.front().generalized_coordinates[i], exact.generalized_coordinates[i]);
EXPECT_DOUBLE_EQ(grid.history.front().velocity[i], exact.velocity[i]);
EXPECT_DOUBLE_EQ(grid.history.front().acceleration[i], exact.acceleration[i]);
EXPECT_DOUBLE_EQ(grid.history.front().algorithmic_acceleration[i], exact.acceleration[i]);
}
for (std::size_t index = 0U; index < grid.history.size(); ++index) {
const auto& frame = grid.history[index];
EXPECT_DOUBLE_EQ(frame.time, static_cast<double>(index) / 64.0);
EXPECT_EQ(frame.time_integration_formulation,
fesa::DynamicTimeIntegrationFormulation::kReducedCoordinateHht);
EXPECT_EQ(frame.generalized_coordinates.Size(), fixture.dofs.FullDofCount());
EXPECT_EQ(frame.velocity.Size(), fixture.dofs.FullDofCount());
EXPECT_EQ(frame.acceleration.Size(), fixture.dofs.FullDofCount());
for (const auto* channel : {&frame.generalized_coordinates, &frame.velocity,
&frame.acceleration, &frame.algorithmic_acceleration})
for (std::size_t i = 0U; i < channel->Size(); ++i)
EXPECT_TRUE(std::isfinite((*channel)[i]));
for (const double residual : frame.free_residual_metrics)
EXPECT_LE(residual, 1.0e-10);
for (const auto* defect : {&frame.hidden_constraint,
&frame.hidden_velocity_defect,
&frame.hidden_acceleration_defect})
for (std::size_t i = 0U; i < defect->Size(); ++i)
EXPECT_TRUE(std::isfinite((*defect)[i]));
}
EXPECT_EQ(grid.history.back().time_integration_formulation,
fesa::DynamicTimeIntegrationFormulation::kReducedCoordinateHht);
EXPECT_DOUBLE_EQ(grid.history.back().time, 1.0);
EXPECT_GT(grid.maximum_rotation, 0.5);
}
TEST(HhtShellPhysics, C08aRigidManufacturedOrbitReducedCoordinateTimeConvergence) {
const auto fixture = MakeFixture(1U);
std::vector<GridEvidence> grids;
std::vector<std::array<double, 6>> errors;
for (const unsigned denominator : {16U, 32U, 64U, 128U, 256U, 512U, 1024U}) {
SCOPED_TRACE(denominator);
grids.push_back(
RunPlate(fixture, 1.0 / static_cast<double>(denominator), true));
const auto& grid = grids.back();
EXPECT_GT(grid.maximum_rotation, 0.5);
std::array<double, 6> maximum{};
std::array<double, 6> first{};
std::array<double, 6> late{};
std::array<double, 6> final{};
std::array<double, 6> maximum_time{};
std::array<double, 6> recovered_maximum{};
std::array<double, 6> recovered_maximum_time{};
std::array<double, 2> recovered_acceleration_split{};
double recovery_pre_hidden2 = 0.0;
double recovery_post_hidden2 = 0.0;
double recovery_mass_delta_a = 0.0;
double angular_acceleration_null_error = 0.0;
double angular_acceleration_physical_error = 0.0;
for (std::size_t index = 0; index < grid.history.size(); ++index) {
const auto& frame = grid.history[index];
ASSERT_EQ(frame.hidden_velocity_defect.Size(), fixture.domain->Nodes().size());
ASSERT_EQ(frame.hidden_velocity_defect_scale.Size(), frame.hidden_velocity_defect.Size());
ASSERT_EQ(frame.hidden_acceleration_defect.Size(), frame.hidden_velocity_defect.Size());
ASSERT_EQ(frame.hidden_acceleration_defect_scale.Size(), frame.hidden_velocity_defect.Size());
for (std::size_t node = 0U; node < frame.hidden_velocity_defect.Size(); ++node) {
for (const auto values : {
std::make_pair(frame.hidden_velocity_defect[node], frame.hidden_velocity_defect_scale[node]),
std::make_pair(frame.hidden_acceleration_defect[node], frame.hidden_acceleration_defect_scale[node])}) {
ASSERT_TRUE(std::isfinite(values.first));
ASSERT_TRUE(std::isfinite(values.second));
ASSERT_GE(values.second, 0.0);
if (values.second == 0.0)
EXPECT_DOUBLE_EQ(values.first, 0.0);
else
EXPECT_LE(std::abs(values.first) / values.second, 1.0e-10);
}
}
const auto exact = RigidOrbit(fixture, frame.time);
const auto error =
FrameError(frame, exact, fixture.length, grid.end_time);
const auto recovered_error =
RecoveredFrameError(frame, grid.recovered_acceleration[index].value,
exact, fixture.length, grid.end_time);
const auto split =
AccelerationSplit(exact, grid.recovered_acceleration[index].value,
exact.acceleration, grid.end_time);
for (std::size_t channel = 0; channel < 6U; ++channel) {
if (recovered_error[channel] > recovered_maximum[channel])
recovered_maximum_time[channel] = frame.time;
recovered_maximum[channel] =
std::max(recovered_maximum[channel], recovered_error[channel]);
}
for (std::size_t part = 0; part < 2U; ++part)
recovered_acceleration_split[part] =
std::max(recovered_acceleration_split[part], split[part]);
recovery_pre_hidden2 =
std::max(recovery_pre_hidden2,
grid.recovered_acceleration[index].pre_hidden2_relative);
recovery_post_hidden2 =
std::max(recovery_post_hidden2,
grid.recovered_acceleration[index].post_hidden2_relative);
recovery_mass_delta_a =
std::max(recovery_mass_delta_a,
grid.recovered_acceleration[index].mass_delta_a_relative);
if (error[5] > maximum[5]) {
double largest = 0.0;
for (std::size_t node = 0; node < fixture.domain->Nodes().size();
++node) {
const auto offset = 6U * node + 3U;
const auto difference =
Add(Triple(frame.acceleration, offset),
Scale(Triple(exact.acceleration, offset), -1.0L));
const double magnitude = static_cast<double>(Norm(difference));
if (magnitude <= largest) continue;
largest = magnitude;
const auto phi = Triple(frame.generalized_coordinates, offset);
const auto velocity = Triple(frame.velocity, offset);
const auto acceleration = Triple(frame.acceleration, offset);
auto vector3 = [](const L3& value) {
return fesa::Vector3{static_cast<double>(value[0]),
static_cast<double>(value[1]),
static_cast<double>(value[2])};
};
const auto rotation = Require(fesa::EvaluateDynamicRotation(
vector3(phi), {0.0, 0.0, 1.0}, vector3(velocity),
vector3(acceleration)));
const L3 null{rotation.drill_null[0], rotation.drill_null[1],
rotation.drill_null[2]};
angular_acceleration_null_error =
static_cast<double>(std::abs(Dot(null, difference)));
angular_acceleration_physical_error =
static_cast<double>(Norm(Cross(null, difference)));
}
}
for (std::size_t channel = 0; channel < 6U; ++channel) {
if (error[channel] > maximum[channel])
maximum_time[channel] = frame.time;
maximum[channel] = std::max(maximum[channel], error[channel]);
if (index == 1U) first[channel] = error[channel];
if (frame.time >= grid.end_time / 4.0)
late[channel] = std::max(late[channel], error[channel]);
}
final = error;
}
errors.push_back(maximum);
std::cout << "C08a temporal_error h=" << grid.h;
for (const auto& row :
{std::make_pair(" first=", first), std::make_pair(" late=", late),
std::make_pair(" maximum=", maximum),
std::make_pair(" final=", final),
std::make_pair(" maximum_time=", maximum_time)}) {
std::cout << row.first;
for (const double value : row.second) std::cout << value << ',';
}
std::cout << " max_angular_a_null=" << angular_acceleration_null_error
<< " max_angular_a_physical="
<< angular_acceleration_physical_error << '\n';
std::cout << "C08a recovered_diagnostic h=" << grid.h << " max_time_error=";
for (const double value : recovered_maximum) std::cout << value << ',';
std::cout << " max_time=";
for (const double value : recovered_maximum_time) std::cout << value << ',';
std::cout << " angular_a_null=" << recovered_acceleration_split[0]
<< " angular_a_physical=" << recovered_acceleration_split[1]
<< " pre_hidden2=" << recovery_pre_hidden2
<< " post_hidden2=" << recovery_post_hidden2
<< " Mdeltaa=" << recovery_mass_delta_a << '\n';
}
for (std::size_t channel = 0; channel < 6U; ++channel) {
SCOPED_TRACE(channel);
EXPECT_LE(errors.back()[channel], 1.0e-4);
for (std::size_t grid = grids.size() - 3U; grid + 1U < grids.size(); ++grid) {
if (errors[grid][channel] == 0.0 && errors[grid + 1U][channel] == 0.0)
continue;
ASSERT_GT(errors[grid][channel], 0.0);
ASSERT_GT(errors[grid + 1U][channel], 0.0);
EXPECT_GE(std::log2(errors[grid][channel] / errors[grid + 1U][channel]),
1.8);
}
for (std::size_t grid = grids.size() - 3U; grid < grids.size(); ++grid)
EXPECT_GT(errors[grid][channel],
100.0 * std::max(grids[grid].solve_noise[channel],
grids[grid].arithmetic_noise[channel]))
<< "N7 inconclusive: temporal error does not resolve "
"solve/arithmetic noise.";
}
}
TEST(HhtShellPhysics, C08bInitialPhysicalSpectrumProbe) {
const auto fixture = MakeFixture(2U);
const auto parameters = Require(fesa::MakeHhtParameters(-0.05));
const auto assembly =
Evaluate(fixture, EmptyFrame(fixture), 1.0 / 64.0, parameters, false);
const auto print_matrix = [](const char* prefix,
const fesa::SparseMatrix& matrix) {
ASSERT_EQ(matrix.Rows(), 54U);
ASSERT_EQ(matrix.Columns(), 54U);
ASSERT_EQ(matrix.RowOffsets().size(), 55U);
for (std::size_t row = 0; row < matrix.Rows(); ++row) {
std::array<double, 54U> values{};
for (std::size_t index = matrix.RowOffsets()[row];
index < matrix.RowOffsets()[row + 1U]; ++index) {
const auto column = matrix.ColumnIndices()[index];
ASSERT_LT(column, values.size());
values[column] = matrix.Values()[index];
}
std::cout << prefix << " row=" << row
<< " values=" << std::setprecision(17);
for (const double value : values) std::cout << value << ',';
std::cout << '\n';
}
};
// Diagnostic matrix dump for offline static condensation/eigensolution only.
print_matrix("C08b_initial_M", assembly.mass);
print_matrix("C08b_initial_K", assembly.internal_tangent);
}
TEST(HhtShellPhysics,
PredictorStartCompletesPreviouslyFailingLumpedFreePlateGrid) {
const auto fixture = MakeFixture(2U);
const auto evidence = RunPlate(fixture, 1.0 / 256.0, false);
ASSERT_EQ(evidence.history.size(), 65U);
EXPECT_DOUBLE_EQ(evidence.history.back().time, kEndTime);
EXPECT_GE(evidence.maximum_rotation, 0.2);
EXPECT_LT(evidence.maximum_rotation, std::acos(-1.0));
}
TEST(HhtShellPhysics,
C08bFreeFiniteRotationPlateSelfConvergenceAndPhysicalInvariants) {
const auto fixture = MakeFixture(2U);
std::vector<GridEvidence> grids;
for (const unsigned denominator :
{64U, 128U, 256U, 512U, 1024U, 32768U, 65536U, 131072U}) {
SCOPED_TRACE(denominator);
grids.push_back(
RunPlate(fixture, 1.0 / static_cast<double>(denominator), false));
EXPECT_GE(grids.back().maximum_rotation, 0.2);
}
std::vector<std::array<double, 6>> differences;
for (std::size_t pair = 0; pair + 1U < grids.size(); ++pair) {
differences.push_back(
Differences(grids[pair], grids[pair + 1U], fixture.length));
std::cout << "C08b self_difference h=" << grids[pair].h << ' ';
for (const double value : differences.back()) std::cout << value << ',';
std::cout << '\n';
const auto recovered =
RecoveredDifferences(grids[pair], grids[pair + 1U], fixture.length);
std::array<double, 2> acceleration_split{};
double recovery_pre_hidden2 = 0.0;
double recovery_post_hidden2 = 0.0;
double recovery_mass_delta_a = 0.0;
for (std::size_t frame = 0; frame < grids[pair].history.size(); ++frame) {
const auto fine_frame = static_cast<std::size_t>(
std::llround(grids[pair].h / grids[pair + 1U].h)) * frame;
const auto split = AccelerationSplit(
grids[pair + 1U].history[fine_frame],
grids[pair].recovered_acceleration[frame].value,
grids[pair + 1U].recovered_acceleration[fine_frame].value,
grids[pair].end_time);
for (std::size_t part = 0; part < 2U; ++part)
acceleration_split[part] =
std::max(acceleration_split[part], split[part]);
}
for (const auto* grid : {&grids[pair], &grids[pair + 1U]}) {
for (const auto& recovery : grid->recovered_acceleration) {
recovery_pre_hidden2 =
std::max(recovery_pre_hidden2, recovery.pre_hidden2_relative);
recovery_post_hidden2 =
std::max(recovery_post_hidden2, recovery.post_hidden2_relative);
recovery_mass_delta_a =
std::max(recovery_mass_delta_a, recovery.mass_delta_a_relative);
}
}
std::cout << "C08b recovered_diagnostic h=" << grids[pair].h
<< " common_time_difference=";
for (const double value : recovered) std::cout << value << ',';
std::cout << " angular_a_null=" << acceleration_split[0]
<< " angular_a_physical=" << acceleration_split[1]
<< " pre_hidden2=" << recovery_pre_hidden2
<< " post_hidden2=" << recovery_post_hidden2
<< " Mdeltaa=" << recovery_mass_delta_a << '\n';
}
for (std::size_t channel = 0; channel < 6; ++channel) {
SCOPED_TRACE(channel);
EXPECT_LE(differences.back()[channel], 1.0e-4);
for (std::size_t pair = differences.size() - 3U;
pair + 1U < differences.size(); ++pair) {
const double first = differences[pair][channel];
const double second = differences[pair + 1U][channel];
if (first == 0.0 && second == 0.0) continue;
ASSERT_GT(first, 0.0);
ASSERT_GT(second, 0.0);
// For the preserved 1024 -> 32768 gap use the unequal-grid
// Richardson ratio; the final 2:1 triple reduces to log2(d0/d1).
const double coarse_ratio = grids[pair].h / grids[pair + 1U].h;
const double fine_ratio = grids[pair + 1U].h / grids[pair + 2U].h;
const double threshold = (std::pow(coarse_ratio, 1.8) - 1.0) /
(1.0 - std::pow(fine_ratio, -1.8));
EXPECT_GE(first / second, threshold);
}
for (std::size_t pair = 1U; pair < differences.size(); ++pair) {
const double noise = std::max(grids[pair].solve_noise[channel],
grids[pair].arithmetic_noise[channel]) +
std::max(grids[pair + 1U].solve_noise[channel],
grids[pair + 1U].arithmetic_noise[channel]);
EXPECT_GT(differences[pair][channel], 100.0 * noise)
<< "N7 inconclusive: temporal difference does not resolve "
"solve/arithmetic noise.";
}
}
for (const auto member :
{&GridEvidence::energy_error, &GridEvidence::angular_momentum_error}) {
const auto final = grids.size() - 1U;
EXPECT_LT(grids[final - 1U].*member, grids[final - 2U].*member);
EXPECT_LT(grids[final].*member, grids[final - 1U].*member);
EXPECT_LE(grids[final].*member, 0.6 * (grids[final - 1U].*member));
EXPECT_LE(grids[final].*member, 1.0e-3);
}
// In this centered, all-free fixture the exact HHT branch conserves total
// linear momentum at every h. Endpoint equilibrium and CheckUpdates above
// exercise its balance/update identities; temporal strict decrease is not a
// defined P accuracy measure when the exact error is zero.
EXPECT_LE(grids.back().momentum_error, 1.0e-3);
}
TEST(HhtReducedIncrement, FrozenNearestCoordinatesPassPairArithmeticWithoutChangingHigh) {
const auto first = reduced::CheckPairIncrement(
.071707935756794142, -2.6003877354211524e-18, .071709031890658609,
{-1.0961338644697638e-6, -2.0834558726391122e-22},
1.0961338644697645e-6);
EXPECT_TRUE(first.storage_pass);
EXPECT_TRUE(first.arithmetic_pass);
EXPECT_EQ(first.defect, 0.0);
const auto worst = reduced::CheckPairIncrement(
.07170874594859544, -3.911862569787138e-18, .07170906968934286,
{-3.23740747422167e-7, -5.266112996573883e-23},
3.237407474221672e-7);
EXPECT_TRUE(worst.storage_pass);
EXPECT_TRUE(worst.arithmetic_pass);
EXPECT_EQ(worst.defect, 0.0);
// The independently logged requested trace is not reconstructed from high.
const auto missing_low = reduced::CheckPairIncrement(
.07170874594859544, 0.0, .07170906968934286,
{-3.23740747422167e-7, -5.266112996573883e-23},
3.237407474221672e-7);
EXPECT_FALSE(missing_low.arithmetic_pass);
}
TEST(HhtReducedIncrement, StorageRequiresNearestEvenIncludingBothMidpointDirections) {
const double half_upper_spacing = std::ldexp(1.0, -53);
const double odd = std::nextafter(1.0, 2.0);
EXPECT_TRUE(reduced::CheckPairIncrement(1.0, half_upper_spacing, 1.0,
{half_upper_spacing}, half_upper_spacing).storage_pass);
EXPECT_TRUE(reduced::CheckPairIncrement(1.0, -std::ldexp(1.0, -54), 1.0,
{-std::ldexp(1.0, -54)}, std::ldexp(1.0, -54)).storage_pass);
EXPECT_TRUE(reduced::CheckPairIncrement(-1.0, -half_upper_spacing, -1.0,
{-half_upper_spacing}, half_upper_spacing).storage_pass);
const auto odd_tie = reduced::CheckPairIncrement(odd, -half_upper_spacing,
1.0, {half_upper_spacing}, half_upper_spacing);
EXPECT_TRUE(odd_tie.arithmetic_pass);
EXPECT_FALSE(odd_tie.storage_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(-odd, half_upper_spacing, -1.0,
{-half_upper_spacing}, half_upper_spacing).storage_pass);
const auto misplaced_high = reduced::CheckPairIncrement(1.0,
std::ldexp(1.0, -52), 1.0, {std::ldexp(1.0, -52)}, std::ldexp(1.0, -52));
EXPECT_TRUE(misplaced_high.arithmetic_pass);
EXPECT_FALSE(misplaced_high.storage_pass);
}
TEST(HhtReducedIncrement, WholeUpdateAndIndependentTraceRejectMissingCorrection) {
const double correction = std::ldexp(1.0, -54);
const auto valid_whole = reduced::CheckPairIncrement(1.0, 2.0 * correction,
1.0, {correction, 0.0, correction}, 2.0 * correction);
const auto valid_trace = reduced::CheckPairIncrement(1.0, 2.0 * correction,
1.0, {2.0 * correction, 0.0}, 2.0 * correction);
EXPECT_TRUE(valid_whole.arithmetic_pass && valid_whole.storage_pass);
EXPECT_TRUE(valid_trace.arithmetic_pass && valid_trace.storage_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(1.0, correction, 1.0,
{correction, 0.0, correction}, 2.0 * correction).arithmetic_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(1.0, correction, 1.0,
{2.0 * correction, 0.0}, 2.0 * correction).arithmetic_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(1.0, -2.0 * correction, 1.0,
{2.0 * correction, 0.0}, 2.0 * correction).arithmetic_pass);
}
TEST(HhtReducedIncrement, ExactThresholdRejectsTailHiddenByRoundedRatio) {
const double threshold = 1.0e-12;
const double tail = std::ldexp(1.0, -100);
const auto equality = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{threshold}, 1.0);
EXPECT_TRUE(equality.arithmetic_pass);
const auto above = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{threshold, tail}, 1.0);
EXPECT_EQ(above.ratio, threshold);
EXPECT_FALSE(above.arithmetic_pass);
const auto above_decimal = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{threshold, std::ldexp(1.0, -94)}, 1.0);
EXPECT_EQ(above_decimal.ratio, threshold);
EXPECT_FALSE(above_decimal.arithmetic_pass);
const auto below = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{threshold, -tail}, 1.0);
EXPECT_TRUE(below.arithmetic_pass);
const double largest = std::numeric_limits<double>::max();
const auto maximum = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{1.0}, largest);
EXPECT_TRUE(maximum.arithmetic_pass);
const double tiny = std::numeric_limits<double>::denorm_min();
const auto unsupported = reduced::CheckPairIncrement(0.0, 0.0, 0.0,
{tiny}, std::ldexp(1.0, -1000));
EXPECT_FALSE(unsupported.arithmetic_pass);
}
TEST(HhtReducedIncrement, ZeroScaleAndSubnormalArithmeticRemainExact) {
const double tiny = std::numeric_limits<double>::denorm_min();
const auto zero = reduced::CheckPairIncrement(1.0, 0.0, 1.0, {0.0}, 0.0);
EXPECT_TRUE(zero.arithmetic_pass && zero.storage_pass);
const auto fixed_zero = reduced::CheckPairIncrement(0.0, 0.0, 0.0, {0.0}, 0.0);
EXPECT_TRUE(fixed_zero.arithmetic_pass && fixed_zero.storage_pass);
const auto tiny_valid = reduced::CheckPairIncrement(tiny, 0.0, 0.0, {tiny}, tiny);
EXPECT_TRUE(tiny_valid.arithmetic_pass && tiny_valid.storage_pass);
EXPECT_EQ(tiny_valid.defect, 0.0);
const auto tiny_nonzero = reduced::CheckPairIncrement(1.0, tiny, 1.0, {0.0}, 0.0);
EXPECT_TRUE(tiny_nonzero.storage_pass);
EXPECT_FALSE(tiny_nonzero.arithmetic_pass);
EXPECT_EQ(tiny_nonzero.defect, tiny);
EXPECT_FALSE(reduced::CheckPairIncrement(0.0, tiny, 0.0, {tiny}, tiny).storage_pass);
}
TEST(HhtReducedIncrement, NonfiniteAndOverflowFailBeforeAcceptance) {
const double nan = std::numeric_limits<double>::quiet_NaN();
const double infinity = std::numeric_limits<double>::infinity();
for (const auto invalid : {nan, infinity}) {
EXPECT_FALSE(reduced::CheckPairIncrement(invalid, 0.0, 0.0, {0.0}, 0.0).arithmetic_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(0.0, invalid, 0.0, {0.0}, 0.0).storage_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(0.0, 0.0, invalid, {0.0}, 0.0).arithmetic_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(0.0, 0.0, 0.0, {invalid}, 1.0).arithmetic_pass);
EXPECT_FALSE(reduced::CheckPairIncrement(0.0, 0.0, 0.0, {0.0}, invalid).arithmetic_pass);
}
const double largest = std::numeric_limits<double>::max();
const auto overflow = reduced::CheckPairIncrement(largest, largest, 0.0,
{largest}, largest);
EXPECT_FALSE(overflow.arithmetic_pass);
EXPECT_FALSE(overflow.storage_pass);
#if defined(_M_X64) || defined(__SSE2__)
const auto saved_mxcsr = _mm_getcsr();
for (const auto mask : {0x8000U, 0x0040U}) {
_mm_setcsr(saved_mxcsr | mask);
const auto unsupported = reduced::CheckPairIncrement(1.0,
std::numeric_limits<double>::denorm_min(), 1.0, {0.0}, 0.0);
_mm_setcsr(saved_mxcsr);
EXPECT_FALSE(unsupported.arithmetic_pass);
EXPECT_FALSE(unsupported.storage_pass);
}
#endif
}
TEST(HhtReducedLifecycle, AllowsEvaluationAfterCorrection100ButNeverCorrection101) {
using fesa::hht_reduced_internal::CanApplyOuterCorrection;
using fesa::hht_reduced_internal::kMaximumOuterCorrections;
EXPECT_TRUE(CanApplyOuterCorrection(0U));
EXPECT_TRUE(CanApplyOuterCorrection(99U));
EXPECT_FALSE(CanApplyOuterCorrection(100U));
EXPECT_FALSE(CanApplyOuterCorrection(101U));
// The actual executor evaluates acceptance before this correction guard.
// This verifies its budget policy, not a physical 100-correction trajectory.
for (const bool accept_at_100 : {false, true}) {
std::uint32_t corrections = 0U;
std::uint32_t last_evaluation = 0U;
bool accepted = false;
for (std::uint32_t evaluation = 0U;
evaluation <= kMaximumOuterCorrections; ++evaluation) {
last_evaluation = evaluation;
if (accept_at_100 && evaluation == 100U) {
accepted = true;
break;
}
if (!CanApplyOuterCorrection(evaluation)) break;
++corrections;
}
EXPECT_EQ(corrections, 100U);
EXPECT_EQ(last_evaluation, 100U);
EXPECT_EQ(accepted, accept_at_100);
}
}
std::string ReadLifecycleLog(const std::filesystem::path& path) {
std::ifstream stream(path);
std::ostringstream text;
text << stream.rdbuf();
return text.str();
}
class FailAfterAcceptedIncrement final : public fesa::TangentSolver {
public:
explicit FailAfterAcceptedIncrement(std::filesystem::path path)
: path_(std::move(path)) {}
fesa::Status FactorizeFresh(const fesa::SparseMatrix& matrix) override {
std::istringstream lines(ReadLifecycleLog(path_));
std::string line;
while (std::getline(lines, line)) {
if (line.find("\tincrement=1\t") != std::string::npos &&
line.find("\toutcome=accepted") != std::string::npos) {
++failures;
return fesa::Status::Failure(fesa::FailureCategory::kSolver,
{{fesa::Severity::kError, "c10-injected-backend", {}, "DYNAMIC", {},
"Injected backend failure after accepted increment one."}});
}
}
return solver_.FactorizeFresh(matrix);
}
fesa::Status SolveCorrection(const fesa::Vector& rhs,
fesa::Vector& correction) const override {
return solver_.SolveCorrection(rhs, correction);
}
std::size_t failures = 0U;
private:
std::filesystem::path path_;
fesa::MklPardisoTangentSolver solver_;
};
TEST(HhtReducedLifecycle, FailedExecutionDoesNotPublishCandidateOrContaminateRetry) {
auto fixture = MakeFixture(1U, true);
const fesa::SerialParallelFor parallel;
const auto run = [&](fesa::TangentSolver& tangent,
const std::filesystem::path& path) {
fesa::MklPardisoSolver positive;
fesa::NewtonIterationLogWriter log;
Require(log.Open(path));
auto result = fesa::ExecuteReducedHht(*fixture.domain, log, parallel,
positive, tangent);
Require(log.Close());
return result;
};
const auto directory = std::filesystem::temp_directory_path();
const auto baseline_path = directory / "fesa-c10-baseline.log";
const auto failure_path = directory / "fesa-c10-failure.log";
const auto retry_path = directory / "fesa-c10-retry.log";
fesa::MklPardisoTangentSolver baseline_solver;
auto baseline = run(baseline_solver, baseline_path);
ASSERT_TRUE(baseline.HasValue()) << Message(baseline.GetStatus());
ASSERT_EQ(baseline.Value().state.AcceptedFrames().size(), 3U);
EXPECT_GT(baseline.Value().state.AcceptedFrames()[1U].generalized_coordinates[0U],
0.0);
FailAfterAcceptedIncrement failing(failure_path);
const auto failed = run(failing, failure_path);
ASSERT_FALSE(failed.HasValue());
EXPECT_EQ(failing.failures, 1U);
EXPECT_EQ(failed.GetStatus().Diagnostics().front().code, "c10-injected-backend");
const auto partial_log = ReadLifecycleLog(failure_path);
EXPECT_NE(partial_log.find("\tincrement=2\t"), std::string::npos);
EXPECT_NE(partial_log.find("\toutcome=failed"), std::string::npos);
std::istringstream lines(partial_log);
std::string line;
while (std::getline(lines, line)) {
if (line.find("\toutcome=initial") != std::string::npos ||
line.find("\toutcome=accepted") != std::string::npos) {
EXPECT_NE(ReadLifecycleLog(baseline_path).find(line + '\n'), std::string::npos);
EXPECT_EQ(line.find("\tincrement=2\t"), std::string::npos);
}
}
fesa::MklPardisoTangentSolver retry_solver;
auto retry = run(retry_solver, retry_path);
ASSERT_TRUE(retry.HasValue()) << Message(retry.GetStatus());
const auto& expected = baseline.Value().state.AcceptedFrames();
const auto& actual = retry.Value().state.AcceptedFrames();
ASSERT_EQ(actual.size(), expected.size());
for (std::size_t frame = 0U; frame < actual.size(); ++frame) {
EXPECT_EQ(actual[frame].frame_index, expected[frame].frame_index);
EXPECT_EQ(actual[frame].iteration_count, expected[frame].iteration_count);
EXPECT_EQ(actual[frame].time, expected[frame].time);
for (const auto member : {&Frame::generalized_coordinates, &Frame::velocity,
&Frame::acceleration, &Frame::algorithmic_acceleration,
&Frame::internal_force, &Frame::inertia_force, &Frame::residual,
&Frame::reaction, &Frame::hidden_constraint,
&Frame::hidden_velocity_defect, &Frame::hidden_acceleration_defect}) {
const auto& left = actual[frame].*member;
const auto& right = expected[frame].*member;
ASSERT_EQ(left.Size(), right.Size());
for (std::size_t i = 0U; i < left.Size(); ++i)
EXPECT_EQ(left[i], right[i]);
}
}
EXPECT_EQ(ReadLifecycleLog(retry_path), ReadLifecycleLog(baseline_path));
for (const auto& path : {baseline_path, failure_path, retry_path})
std::filesystem::remove(path);
// Result<DynamicExecutionResult> contains no value after failure. Private
// histories are local to that execution; they are not directly observable.
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink