KOKO\Mimi
1123 lines
60 KiB
C++
1123 lines
60 KiB
C++
#include "analysis/hht_reduced_procedure.h"
|
|
#include "analysis/hht_reduced_integrator.h"
|
|
|
|
#include "equilibrium_algorithm.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
#include "analysis/hht_dynamic_internal.h"
|
|
#include "analysis/hht_reduced_increment.h"
|
|
#include "analysis/hht_reduced_internal.h"
|
|
#include "fesa/analysis/analysis_model.h"
|
|
#include "fesa/analysis/newton_iteration_log.h"
|
|
#include "fesa/solvers/linear/tangent_solver.h"
|
|
|
|
namespace fesa {
|
|
namespace {
|
|
using namespace hht_internal;
|
|
using namespace hht_reduced_internal;
|
|
|
|
Status Failure(const Domain& domain, const std::string& code,
|
|
const std::string& message) {
|
|
return Status::Failure(
|
|
FailureCategory::kSolver,
|
|
{{Severity::kError, code, domain.Dynamic()->dynamic_location, "DYNAMIC",
|
|
domain.Dynamic()->source_step_name_raw, message}});
|
|
}
|
|
|
|
Status WithProcedureContext(const Domain& domain, const Status& status,
|
|
const char* stage, const std::uint32_t increment,
|
|
const double time) {
|
|
std::vector<Diagnostic> diagnostics = status.Diagnostics();
|
|
std::ostringstream message;
|
|
message << "stage=" << stage << ", step="
|
|
<< domain.Dynamic()->source_step_name_raw << ", increment="
|
|
<< increment << ", time=" << time << ".";
|
|
diagnostics.push_back({Severity::kError, "dynamic-procedure-context",
|
|
domain.Dynamic()->dynamic_location, "DYNAMIC",
|
|
domain.Dynamic()->source_step_name_raw,
|
|
message.str()});
|
|
if (const auto category = status.Category(); category.has_value())
|
|
return Status::Failure(*category, std::move(diagnostics));
|
|
return Status::Failure(std::move(diagnostics));
|
|
}
|
|
|
|
bool UpdateEqual(const double left, const std::initializer_list<double> terms) {
|
|
double right = 0.0;
|
|
double scale = 0.0;
|
|
for (const double term : terms) {
|
|
right += term;
|
|
scale += std::abs(term);
|
|
}
|
|
const double defect = std::abs(left - right);
|
|
return std::isfinite(defect) && std::isfinite(scale) &&
|
|
(scale == 0.0 ? defect == 0.0 : defect / scale <= 1e-12);
|
|
}
|
|
|
|
bool PrivateCorrectionEqual(const FixedChart& chart, const std::size_t coordinate,
|
|
const Vector& full_algorithmic,
|
|
const Vector& private_algorithmic,
|
|
const Vector& private_physical, const double alpha) {
|
|
if (!UpdateEqual((1.0 + alpha) * private_physical[coordinate],
|
|
{private_algorithmic[coordinate]})) return false;
|
|
const auto& column = chart.p_columns[coordinate];
|
|
if (!column.fixed_plane &&
|
|
!UpdateEqual(full_algorithmic[column.support[0U].dof],
|
|
{private_algorithmic[coordinate]})) return false;
|
|
double sum = 0.0;
|
|
double compensation = 0.0;
|
|
double scale = std::abs(private_algorithmic[coordinate]);
|
|
for (const auto& entry : column.support) {
|
|
const double term = entry.value * full_algorithmic[entry.dof];
|
|
const double next = sum + term;
|
|
compensation += std::abs(sum) >= std::abs(term)
|
|
? (sum - next) + term : (term - next) + sum;
|
|
sum = next;
|
|
scale += std::abs(term);
|
|
}
|
|
const double defect = std::abs((sum + compensation) - private_algorithmic[coordinate]);
|
|
return std::isfinite(scale) && std::isfinite(defect) &&
|
|
(scale == 0.0 ? defect == 0.0 : defect / scale <= 1e-12);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void AdvanceCoordinate(const double delta, double* high, double* low) {
|
|
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);
|
|
}
|
|
|
|
void AddIncrementTraceTerm(const double value, double* sum,
|
|
double* compensation) {
|
|
const double next = *sum + value;
|
|
if (std::abs(*sum) >= std::abs(value))
|
|
*compensation += (*sum - next) + value;
|
|
else
|
|
*compensation += (value - next) + *sum;
|
|
*sum = next;
|
|
}
|
|
|
|
bool GlobalBasisEqual(const FixedChart& chart, const Vector& full,
|
|
const Vector& p, const Vector& z) {
|
|
Vector sums{chart.full_dof_count};
|
|
Vector compensations{chart.full_dof_count};
|
|
Vector scales{chart.full_dof_count};
|
|
const auto add = [&](const std::vector<FixedBasisColumn>& columns,
|
|
const Vector& coordinates) {
|
|
for (std::size_t i = 0U; i < coordinates.Size(); ++i)
|
|
for (const auto& entry : columns[i].support) {
|
|
const double term = entry.value * coordinates[i];
|
|
AddIncrementTraceTerm(term, &sums[entry.dof], &compensations[entry.dof]);
|
|
scales[entry.dof] += std::abs(term);
|
|
}
|
|
};
|
|
add(chart.p_columns, p);
|
|
add(chart.z_columns, z);
|
|
for (std::size_t i = 0U; i < full.Size(); ++i) {
|
|
const double defect = std::abs(full[i] - (sums[i] + compensations[i]));
|
|
if (!std::isfinite(defect) || !std::isfinite(scales[i]) ||
|
|
(scales[i] == 0.0 ? defect != 0.0 : defect / scales[i] > 1e-12)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ResidualRecord(const DofManager& dofs,
|
|
const DynamicAcceptedFrameState& frame,
|
|
DynamicNewtonIterationLogRecord* record) {
|
|
record->residual_numerator = {};
|
|
record->residual_scale = {};
|
|
for (const auto full : dofs.FreeDofs()) {
|
|
const auto channel = full % 6U < 3U ? 0U : 1U;
|
|
record->residual_numerator[channel] =
|
|
(std::max)(record->residual_numerator[channel],
|
|
std::abs(frame.residual[full]));
|
|
record->residual_scale[channel] =
|
|
(std::max)(record->residual_scale[channel], frame.residual_scale[full]);
|
|
}
|
|
record->residual_pass = frame.free_residual_metrics[0U] <= 1e-10 &&
|
|
frame.free_residual_metrics[1U] <= 1e-10;
|
|
}
|
|
|
|
void CorrectionRecord(const Vector& coordinate, const Vector& velocity,
|
|
const Vector& acceleration,
|
|
const Vector& full_algorithmic,
|
|
const Vector& reduced_algorithmic,
|
|
const Vector& reduced_physical,
|
|
const FixedChart& chart, const DofManager& dofs,
|
|
const double length, const double h, const double alpha,
|
|
DynamicNewtonIterationLogRecord* record) {
|
|
record->coordinate_correction = {};
|
|
record->velocity_correction = {};
|
|
record->acceleration_correction = {};
|
|
record->algorithmic_correction = {};
|
|
for (const auto full : dofs.FreeDofs()) {
|
|
const auto channel = full % 6U < 3U ? 0U : 1U;
|
|
const double scale = channel == 0U ? length : 1.0;
|
|
record->coordinate_correction[channel] =
|
|
(std::max)(record->coordinate_correction[channel],
|
|
std::abs(coordinate[full]) / scale);
|
|
record->velocity_correction[channel] =
|
|
(std::max)(record->velocity_correction[channel],
|
|
std::abs(h * velocity[full]) / scale);
|
|
record->acceleration_correction[channel] =
|
|
(std::max)(record->acceleration_correction[channel],
|
|
std::abs(h * h * acceleration[full]) / scale);
|
|
record->algorithmic_correction[channel] =
|
|
(std::max)(record->algorithmic_correction[channel],
|
|
std::abs(h * h * full_algorithmic[full]) / scale);
|
|
}
|
|
record->correction_pass = true;
|
|
for (std::size_t channel = 0U; channel < 2U; ++channel) {
|
|
record->correction_pass = record->correction_pass &&
|
|
record->coordinate_correction[channel] <= 1e-10 &&
|
|
record->velocity_correction[channel] <= 1e-10 &&
|
|
record->acceleration_correction[channel] <= 1e-10 &&
|
|
record->algorithmic_correction[channel] <= 1e-10;
|
|
}
|
|
if (reduced_algorithmic.Size() != chart.p_columns.size() ||
|
|
reduced_physical.Size() != chart.p_columns.size()) {
|
|
record->correction_pass = false;
|
|
return;
|
|
}
|
|
for (std::size_t i = 0U; i < chart.p_dofs.size(); ++i)
|
|
record->correction_pass = record->correction_pass &&
|
|
PrivateCorrectionEqual(chart, i, full_algorithmic,
|
|
reduced_algorithmic, reduced_physical, alpha);
|
|
}
|
|
|
|
bool ExactlyEqual(const Vector& left, const Vector& right) {
|
|
if (left.Size() != right.Size()) return false;
|
|
for (std::size_t i = 0U; i < left.Size(); ++i)
|
|
if (left[i] != right[i]) return false;
|
|
return true;
|
|
}
|
|
|
|
Status CheckReducedUpdates(const Domain& domain,
|
|
const DynamicAcceptedFrameState& old,
|
|
const DynamicAcceptedFrameState& frame,
|
|
const Vector& predictor_coordinates,
|
|
const Vector& predictor_velocity,
|
|
const Vector& physical_coordinates,
|
|
const Vector& physical_velocity,
|
|
const Vector& physical_acceleration,
|
|
const Vector& algebraic_coordinates,
|
|
const Vector& algebraic_velocity,
|
|
const Vector& algebraic_acceleration,
|
|
const Vector& algorithmic_acceleration,
|
|
const Vector& old_private_coordinates,
|
|
const Vector& old_private_velocity,
|
|
const Vector& old_private_physical_acceleration,
|
|
const Vector& old_private_algorithmic_acceleration,
|
|
const Vector& increment_trace,
|
|
const Vector& increment_trace_compensation,
|
|
const Vector& increment_trace_absolute_sum,
|
|
const FixedChart& chart,
|
|
const Vector& chosen_start_coordinates,
|
|
const Vector& coordinate_low,
|
|
const HhtParameters& parameters, double h) {
|
|
if (!GlobalBasisEqual(chart, frame.generalized_coordinates, physical_coordinates,
|
|
algebraic_coordinates) ||
|
|
!GlobalBasisEqual(chart, frame.velocity, physical_velocity, algebraic_velocity) ||
|
|
!GlobalBasisEqual(chart, frame.acceleration, physical_acceleration, algebraic_acceleration))
|
|
return Failure(domain, "reduced-dynamic-update-inconsistency",
|
|
"Global HHT reconstruction differs from its actual sparse basis products.");
|
|
for (std::size_t i = 0U; i < physical_coordinates.Size(); ++i) {
|
|
const auto inconsistent = [&](const char* reason) {
|
|
const auto pair_trace = CheckPairIncrement(physical_coordinates[i], coordinate_low[i],
|
|
old_private_coordinates[i], {increment_trace[i], increment_trace_compensation[i]},
|
|
increment_trace_absolute_sum[i]);
|
|
std::ostringstream message;
|
|
message << std::setprecision(17) << reason << " i=" << i
|
|
<< ", coordinate_label=" << chart.p_dofs[i]
|
|
<< ", channel=" << PhysicalCoordinateChannel(chart, i)
|
|
<< ", old_p=" << old_private_coordinates[i]
|
|
<< ", start_p=" << chosen_start_coordinates[i]
|
|
<< ", p=" << physical_coordinates[i]
|
|
<< ", p_low=" << coordinate_low[i]
|
|
<< ", actual_increment=" << physical_coordinates[i] - old_private_coordinates[i]
|
|
<< ", trace_sum=" << increment_trace[i]
|
|
<< ", trace_compensation=" << increment_trace_compensation[i]
|
|
<< ", trace_scale=" << increment_trace_absolute_sum[i]
|
|
<< ", pair_trace_defect=" << pair_trace.defect
|
|
<< ", pair_trace_ratio=" << pair_trace.ratio
|
|
<< ", pair_storage=" << pair_trace.storage_pass
|
|
<< ", representation_distance=" << std::abs(coordinate_low[i])
|
|
<< ", pp=" << predictor_coordinates[i]
|
|
<< ", h_vold=" << h * old_private_velocity[i]
|
|
<< ", h2_old_Ar=" << h * h * (0.5 - parameters.beta) * old_private_algorithmic_acceleration[i]
|
|
<< ", beta_h2_Ar=" << parameters.beta * h * h * algorithmic_acceleration[i] << ".";
|
|
return Failure(domain, "reduced-dynamic-update-inconsistency", message.str());
|
|
};
|
|
if (!UpdateEqual(physical_coordinates[i],
|
|
{predictor_coordinates[i], parameters.beta * h * h *
|
|
algorithmic_acceleration[i]}) ||
|
|
!UpdateEqual(physical_velocity[i],
|
|
{predictor_velocity[i], parameters.gamma * h *
|
|
algorithmic_acceleration[i]}) ||
|
|
!UpdateEqual((1.0 + parameters.alpha) * physical_acceleration[i],
|
|
{algorithmic_acceleration[i],
|
|
parameters.alpha * old_private_physical_acceleration[i]})) {
|
|
return inconsistent("Reduced HHT private history or public auxiliary rate is inconsistent.");
|
|
}
|
|
const double velocity_term = h * old_private_velocity[i];
|
|
const double old_rate_term = h * h * (0.5 - parameters.beta) *
|
|
old_private_algorithmic_acceleration[i];
|
|
const double new_rate_term = h * h * parameters.beta *
|
|
algorithmic_acceleration[i];
|
|
const auto whole = CheckPairIncrement(physical_coordinates[i], coordinate_low[i],
|
|
old_private_coordinates[i], {velocity_term, old_rate_term, new_rate_term},
|
|
std::abs(velocity_term) + std::abs(old_rate_term) + std::abs(new_rate_term));
|
|
if (!whole.storage_pass)
|
|
return inconsistent("Reduced HHT coordinate high is not the RN-even pair value.");
|
|
if (!whole.arithmetic_pass) {
|
|
return inconsistent("Reduced HHT resolved private update is inconsistent.");
|
|
}
|
|
const auto requested = CheckPairIncrement(physical_coordinates[i], coordinate_low[i],
|
|
old_private_coordinates[i], {increment_trace[i], increment_trace_compensation[i]},
|
|
increment_trace_absolute_sum[i]);
|
|
if (!requested.arithmetic_pass) {
|
|
return inconsistent("Reduced HHT increment trace is inconsistent.");
|
|
}
|
|
}
|
|
for (std::size_t i = 0U; i < frame.algorithmic_acceleration.Size(); ++i)
|
|
if (!UpdateEqual(frame.algorithmic_acceleration[i],
|
|
{(1.0 + parameters.alpha) * frame.acceleration[i],
|
|
-parameters.alpha * old.acceleration[i]}))
|
|
return Failure(domain, "reduced-dynamic-update-inconsistency",
|
|
"Public HHT auxiliary acceleration is inconsistent.");
|
|
return Status::Ok();
|
|
}
|
|
|
|
// Private nonvirtual primitive: keep velocity assignment before acceleration
|
|
// evaluation, including per-index position retries. No accepted state changes.
|
|
void EvaluateReducedShellRate(double predictor_velocity,
|
|
double algorithmic_acceleration,
|
|
double old_acceleration, double h,
|
|
const HhtParameters& parameters,
|
|
double* velocity, double* acceleration) {
|
|
*velocity = predictor_velocity + parameters.gamma * h * algorithmic_acceleration;
|
|
*acceleration = (algorithmic_acceleration + parameters.alpha * old_acceleration) /
|
|
(1.0 + parameters.alpha);
|
|
}
|
|
|
|
class ReducedCoordinateShellHhtIntegrator final : public ShellHhtIntegrator {
|
|
public:
|
|
ReducedShellPredictor
|
|
Predict(const ReducedHistory& history, double h,
|
|
const HhtParameters& parameters) const override {
|
|
Vector pp{history.p.Size()}, vpp{history.p.Size()};
|
|
for (std::size_t i = 0U; i < history.p.Size(); ++i) {
|
|
pp[i] =
|
|
history.p[i] + h * history.velocity[i] +
|
|
h * h * (0.5 - parameters.beta) * history.algorithmic_acceleration[i];
|
|
vpp[i] = history.velocity[i] + h * (1.0 - parameters.gamma) *
|
|
history.algorithmic_acceleration[i];
|
|
}
|
|
Vector coordinate_low{history.p.Size()};
|
|
Vector increment_trace{history.p.Size()};
|
|
Vector increment_trace_compensation{history.p.Size()};
|
|
Vector increment_trace_absolute_sum{history.p.Size()};
|
|
for (std::size_t i = 0U; i < history.p.Size(); ++i) {
|
|
const double velocity_term = h * history.velocity[i];
|
|
const double old_acceleration_term =
|
|
h * h * (0.5 - parameters.beta) * history.algorithmic_acceleration[i];
|
|
const double first_sum = history.p[i] + velocity_term;
|
|
coordinate_low[i] =
|
|
AdditionLowPart(history.p[i], velocity_term, first_sum) +
|
|
AdditionLowPart(first_sum, old_acceleration_term, pp[i]);
|
|
AddIncrementTraceTerm(velocity_term, &increment_trace[i],
|
|
&increment_trace_compensation[i]);
|
|
AddIncrementTraceTerm(old_acceleration_term, &increment_trace[i],
|
|
&increment_trace_compensation[i]);
|
|
increment_trace_absolute_sum[i] =
|
|
std::abs(velocity_term) + std::abs(old_acceleration_term);
|
|
}
|
|
return {std::move(pp),
|
|
std::move(vpp),
|
|
std::move(coordinate_low),
|
|
std::move(increment_trace),
|
|
std::move(increment_trace_compensation),
|
|
std::move(increment_trace_absolute_sum)};
|
|
}
|
|
void EvaluateRates(const ReducedShellRateRequest& request,
|
|
Vector& trial_v, Vector& trial_a) const override {
|
|
const auto& history = request.history;
|
|
const auto& trial_algorithmic = request.trial_algorithmic;
|
|
const auto& vpp = request.vpp;
|
|
const auto& parameters = request.parameters;
|
|
const double h = request.h;
|
|
for (std::size_t i = 0U; i < history.p.Size(); ++i) {
|
|
if (request.copy_translation_rates &&
|
|
PhysicalCoordinateChannel(request.chart, i) == 0U) {
|
|
trial_v[i] = request.retained_velocity[i];
|
|
trial_a[i] = request.retained_acceleration[i];
|
|
} else {
|
|
EvaluateReducedShellRate(
|
|
vpp[i], trial_algorithmic[i], history.acceleration[i], h, parameters,
|
|
&trial_v[i], &trial_a[i]);
|
|
}
|
|
}
|
|
}
|
|
Result<ReconstructedRates>
|
|
ReconstructPhysicalRates(const FixedChart& chart, const EmbeddingRoot& root,
|
|
const Vector& velocity, const Vector& acceleration,
|
|
TangentSolver& solver) const override {
|
|
return hht_reduced_internal::ReconstructPhysicalRates(chart, root, velocity,
|
|
acceleration, solver);
|
|
}
|
|
};
|
|
|
|
struct Trial {
|
|
DynamicAssembly assembly;
|
|
EmbeddingRoot root;
|
|
Vector p{0U};
|
|
Vector velocity{0U};
|
|
Vector acceleration{0U};
|
|
Vector algorithmic_acceleration{0U};
|
|
Vector algebraic_velocity{0U};
|
|
Vector algebraic_acceleration{0U};
|
|
};
|
|
} // namespace
|
|
|
|
Result<DynamicExecutionResult> ExecuteReducedHht(
|
|
const Domain& domain, NewtonIterationLogWriter& log,
|
|
const ParallelFor& parallel_for, LinearSolver& positive_solver,
|
|
TangentSolver& tangent_solver) {
|
|
const ReducedCoordinateShellHhtIntegrator integrator;
|
|
NewtonStepAlgorithm algorithm;
|
|
return ExecuteReducedHht(domain, log, parallel_for, positive_solver,
|
|
tangent_solver, integrator, algorithm);
|
|
}
|
|
|
|
Result<DynamicExecutionResult> ExecuteReducedHht(
|
|
const Domain& domain, NewtonIterationLogWriter& log,
|
|
const ParallelFor& parallel_for, LinearSolver& positive_solver,
|
|
TangentSolver& tangent_solver, const ShellHhtIntegrator& integrator,
|
|
EquilibriumAlgorithm& algorithm) {
|
|
if (domain.Dynamic() == nullptr)
|
|
return Result<DynamicExecutionResult>::Failure(Status::Failure(
|
|
FailureCategory::kModel, {{Severity::kError, "invalid-dynamic-step", {},
|
|
"DYNAMIC", {},
|
|
"HHT requires exactly one dynamic step."}}));
|
|
auto model = AnalysisModel::Create(domain);
|
|
if (!model.HasValue()) return Result<DynamicExecutionResult>::Failure(model.GetStatus());
|
|
auto dofs_result = DofManager::Create(model.Value());
|
|
if (!dofs_result.HasValue()) return Result<DynamicExecutionResult>::Failure(dofs_result.GetStatus());
|
|
const auto& dofs = dofs_result.Value();
|
|
auto state_result = DynamicAnalysisState::Create(domain, dofs);
|
|
if (!state_result.HasValue()) return Result<DynamicExecutionResult>::Failure(state_result.GetStatus());
|
|
auto state = std::move(state_result.Value());
|
|
auto shells = BuildRuntimeShells(domain, dofs);
|
|
if (!shells.HasValue()) return Result<DynamicExecutionResult>::Failure(shells.GetStatus());
|
|
auto length_result = ReferenceLength(domain);
|
|
if (!length_result.HasValue()) return Result<DynamicExecutionResult>::Failure(length_result.GetStatus());
|
|
const double length = length_result.Value();
|
|
auto loads = AssembleLoads(domain, dofs);
|
|
if (!loads.HasValue()) return Result<DynamicExecutionResult>::Failure(loads.GetStatus());
|
|
auto parameters_result = MakeHhtParameters(domain.Dynamic()->alpha);
|
|
if (!parameters_result.HasValue()) return Result<DynamicExecutionResult>::Failure(parameters_result.GetStatus());
|
|
const HhtParameters parameters = parameters_result.Value();
|
|
const double h = domain.Dynamic()->initial_increment;
|
|
const Vector zero{dofs.FullDofCount()};
|
|
|
|
DynamicAcceptedFrameState frame{};
|
|
frame.is_initial = true;
|
|
frame.time_integration_formulation =
|
|
DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
|
|
for (auto* values : {&frame.generalized_coordinates, &frame.velocity,
|
|
&frame.acceleration, &frame.algorithmic_acceleration})
|
|
*values = Vector(dofs.FullDofCount());
|
|
frame.external_force = loads.Value()[0U];
|
|
auto initial = EvaluateAssembly(domain, dofs, shells.Value(), frame,
|
|
loads.Value()[1U], h, parameters,
|
|
parallel_for, true);
|
|
if (!initial.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, initial.GetStatus(), "initial", 0U, 0.0));
|
|
const auto null_nodes = NullNodes(dofs, initial.Value().rotations);
|
|
auto initial_acceleration = InitializeAcceleration(domain, dofs, initial.Value(), length,
|
|
positive_solver, tangent_solver);
|
|
if (!initial_acceleration.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, initial_acceleration.GetStatus(), "initial", 0U, 0.0));
|
|
frame.acceleration = initial_acceleration.Value();
|
|
frame.algorithmic_acceleration = initial_acceleration.Value();
|
|
initial = EvaluateAssembly(domain, dofs, shells.Value(), frame, loads.Value()[1U], h,
|
|
parameters, parallel_for, true);
|
|
if (!initial.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, initial.GetStatus(), "initial", 0U, 0.0));
|
|
frame = initial.Value().frame;
|
|
frame.time_integration_formulation = DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
|
|
auto chart = BuildFixedChart(dofs, initial.Value().rotations);
|
|
if (!chart.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, chart.GetStatus(), "initial", 0U, 0.0));
|
|
auto p0 = ProjectPhysical(chart.Value(), frame.generalized_coordinates);
|
|
auto vp0 = ProjectPhysical(chart.Value(), frame.velocity);
|
|
auto ap0 = ProjectPhysical(chart.Value(), frame.acceleration);
|
|
auto z0 = ProjectAlgebraic(chart.Value(), frame.generalized_coordinates);
|
|
for (const auto* projected : {&p0, &vp0, &ap0, &z0})
|
|
if (!projected->HasValue()) return Result<DynamicExecutionResult>::Failure(projected->GetStatus());
|
|
ReducedHistory history{std::move(p0.Value()), std::move(vp0.Value()), ap0.Value(),
|
|
ap0.Value(), std::move(z0.Value())};
|
|
auto initial_p_acceleration = Lift(chart.Value(), history.acceleration,
|
|
Vector{chart.Value().z_columns.size()});
|
|
if (!initial_p_acceleration.HasValue())
|
|
return Result<DynamicExecutionResult>::Failure(initial_p_acceleration.GetStatus());
|
|
bool position_geometry_failure = false;
|
|
const auto position_operators = [&](const DynamicAcceptedFrameState& template_frame,
|
|
const Vector& q) -> Result<ConstraintOperators> {
|
|
auto position = template_frame;
|
|
position.generalized_coordinates = q;
|
|
position.velocity = zero;
|
|
position.acceleration = zero;
|
|
position.algorithmic_acceleration = zero;
|
|
auto assembly = EvaluateAssembly(domain, dofs, shells.Value(), position,
|
|
loads.Value()[1U], h, parameters,
|
|
parallel_for, false);
|
|
if (!assembly.HasValue()) {
|
|
if (!assembly.GetStatus().Diagnostics().empty()) {
|
|
const auto& code = assembly.GetStatus().Diagnostics().front().code;
|
|
position_geometry_failure =
|
|
code == "invalid-nonlinear-shell-geometry" ||
|
|
code == "invalid-nonlinear-shell-director" ||
|
|
code == "invalid-nonlinear-inertia-geometry" ||
|
|
code == "invalid-nonlinear-inertia-director";
|
|
if (code == "invalid-dynamic-rotation") {
|
|
const double margin = std::sqrt(std::numeric_limits<double>::epsilon());
|
|
const double pi = std::acos(-1.0);
|
|
for (std::size_t node = 0U; node < domain.Nodes().size(); ++node) {
|
|
double squared = 0.0;
|
|
for (std::size_t component = 0U; component < 3U; ++component) {
|
|
const double value = q[6U * node + 3U + component];
|
|
squared += value * value;
|
|
}
|
|
const double angle = std::sqrt(squared);
|
|
if (!std::isfinite(angle) || !(pi - angle > margin)) {
|
|
position_geometry_failure = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Result<ConstraintOperators>::Failure(assembly.GetStatus());
|
|
}
|
|
return EvaluateConstraintOperators(domain, dofs, shells.Value(), assembly.Value(),
|
|
chart.Value(), zero, zero);
|
|
};
|
|
auto root0 = SolveEmbeddingRoot(chart.Value(), history.p, history.z,
|
|
[&](const Vector& q) { return position_operators(frame, q); },
|
|
tangent_solver);
|
|
if (!root0.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, root0.GetStatus(), "inner-position", 0U, 0.0));
|
|
auto rates0 = integrator.ReconstructPhysicalRates(chart.Value(), root0.Value(), history.velocity,
|
|
history.acceleration, tangent_solver);
|
|
if (!rates0.HasValue()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, rates0.GetStatus(), "inner-rates", 0U, 0.0));
|
|
// Frame zero remains the independently recovered physical state. Its
|
|
// position and velocity must be represented exactly; acceleration is
|
|
// certified below by the existing hidden-rate and positive-mass evidence,
|
|
// rather than requiring two independent solves to round identically.
|
|
if (!ExactlyEqual(root0.Value().q, frame.generalized_coordinates) ||
|
|
!ExactlyEqual(rates0.Value().velocity, frame.velocity))
|
|
return Result<DynamicExecutionResult>::Failure(
|
|
Failure(domain, "dynamic-initial-consistency",
|
|
"The initialized full HHT position or velocity is not exactly representable by the fixed reduced chart."));
|
|
auto reconstructed_zero = frame;
|
|
reconstructed_zero.generalized_coordinates = root0.Value().q;
|
|
reconstructed_zero.velocity = rates0.Value().velocity;
|
|
reconstructed_zero.acceleration = rates0.Value().acceleration;
|
|
reconstructed_zero.algorithmic_acceleration = rates0.Value().acceleration;
|
|
auto reconstructed_assembly = EvaluateAssembly(
|
|
domain, dofs, shells.Value(), reconstructed_zero, loads.Value()[1U], h,
|
|
parameters, parallel_for, true);
|
|
if (!reconstructed_assembly.HasValue())
|
|
return Result<DynamicExecutionResult>::Failure(WithProcedureContext(
|
|
domain, reconstructed_assembly.GetStatus(), "initial", 0U, 0.0));
|
|
Status reconstructed_status = CompleteConstraintEvidence(
|
|
domain, dofs, reconstructed_assembly.Value(), length, null_nodes,
|
|
positive_solver, tangent_solver, &reconstructed_zero);
|
|
if (!reconstructed_status.IsOk())
|
|
return Result<DynamicExecutionResult>::Failure(WithProcedureContext(
|
|
domain, reconstructed_status, "initial", 0U, 0.0));
|
|
reconstructed_status = CompleteEquilibrium(domain, dofs,
|
|
reconstructed_assembly.Value(),
|
|
&reconstructed_zero);
|
|
if (!reconstructed_status.IsOk())
|
|
return Result<DynamicExecutionResult>::Failure(WithProcedureContext(
|
|
domain, reconstructed_status, "initial", 0U, 0.0));
|
|
if (!(reconstructed_assembly.Value().frame.free_residual_metrics[0U] <=
|
|
1.0e-10 &&
|
|
reconstructed_assembly.Value().frame.free_residual_metrics[1U] <=
|
|
1.0e-10)) {
|
|
const auto& reconstructed = reconstructed_assembly.Value().frame;
|
|
DynamicNewtonIterationLogRecord initial_record{};
|
|
ResidualRecord(dofs, reconstructed, &initial_record);
|
|
std::ostringstream message;
|
|
message << std::setprecision(17)
|
|
<< "The reconstructed frame-zero physical residual is not acceptable; "
|
|
<< "initial_u=" << frame.free_residual_metrics[0U]
|
|
<< ", initial_phi=" << frame.free_residual_metrics[1U];
|
|
for (std::size_t channel = 0U; channel < 2U; ++channel) {
|
|
std::size_t worst = 0U;
|
|
double maximum = -1.0;
|
|
for (const auto full : dofs.FreeDofs()) {
|
|
if ((full % 6U < 3U ? 0U : 1U) == channel &&
|
|
std::abs(reconstructed.residual[full]) > maximum) {
|
|
worst = full;
|
|
maximum = std::abs(reconstructed.residual[full]);
|
|
}
|
|
}
|
|
message << "; channel=" << channel
|
|
<< ", ratio=" << reconstructed.free_residual_metrics[channel]
|
|
<< ", numerator=" << initial_record.residual_numerator[channel]
|
|
<< ", scale=" << initial_record.residual_scale[channel];
|
|
if (maximum >= 0.0)
|
|
message << ", full=" << worst << ", node=" << worst / 6U
|
|
<< ", residual=" << reconstructed.residual[worst]
|
|
<< ", row_scale=" << reconstructed.residual_scale[worst]
|
|
<< ", original_residual=" << frame.residual[worst]
|
|
<< ", q=" << reconstructed.generalized_coordinates[worst]
|
|
<< ", v=" << reconstructed.velocity[worst]
|
|
<< ", a=" << reconstructed.acceleration[worst]
|
|
<< ", original_a=" << frame.acceleration[worst]
|
|
<< ", delta_a=" << reconstructed.acceleration[worst] -
|
|
frame.acceleration[worst];
|
|
}
|
|
Vector acceleration_delta{frame.acceleration.Size()};
|
|
for (std::size_t full = 0U; full < acceleration_delta.Size(); ++full)
|
|
acceleration_delta[full] = reconstructed.acceleration[full] - frame.acceleration[full];
|
|
const auto mass_delta = initial.Value().mass.Multiply(acceleration_delta);
|
|
const auto graph = GraphJacobian(root0.Value().operators, chart.Value());
|
|
const auto hessian_velocity = ContractConstraintHessian(
|
|
root0.Value().operators, frame.velocity, frame.velocity);
|
|
// Failure-only evidence is bounded to sixteen canonical null rows. C09's
|
|
// eight-node covariance fixture is fully represented, without state edits.
|
|
const auto count = (std::min)(root0.Value().operators.rows.size(), std::size_t{16U});
|
|
for (std::size_t row = 0U; row < count; ++row) {
|
|
const auto node = chart.Value().null_nodes[row];
|
|
const auto& null = initial.Value().rotations[node].drill_null;
|
|
const auto& primitive = root0.Value().operators.rows[row];
|
|
Vector projected_gradient{frame.acceleration.Size()};
|
|
for (std::size_t component = 0U; component < 3U; ++component) {
|
|
const auto full = 6U * node + 3U + component;
|
|
for (std::size_t index = initial.Value().internal_tangent.RowOffsets()[full];
|
|
index < initial.Value().internal_tangent.RowOffsets()[full + 1U]; ++index)
|
|
projected_gradient[initial.Value().internal_tangent.ColumnIndices()[index]] +=
|
|
null[component] * initial.Value().internal_tangent.Values()[index];
|
|
}
|
|
double original_dot = 0.0, reconstructed_dot = 0.0, projected_dot = 0.0;
|
|
double time_velocity = 0.0;
|
|
for (const auto& entry : primitive.time_gradient)
|
|
time_velocity += entry.value * frame.velocity[entry.dof];
|
|
double partition_rhs = -hessian_velocity[row] - 2.0 * time_velocity - primitive.time_second;
|
|
std::array<double, 3U> translation_sum{}, projected_translation_sum{};
|
|
for (std::size_t full = 0U; full < frame.acceleration.Size(); ++full) {
|
|
projected_dot += projected_gradient[full] * frame.acceleration[full];
|
|
if (full % 6U < 3U)
|
|
projected_translation_sum[full % 6U] += projected_gradient[full];
|
|
}
|
|
for (const auto& entry : primitive.gradient) {
|
|
original_dot += entry.value * frame.acceleration[entry.dof];
|
|
reconstructed_dot += entry.value * reconstructed.acceleration[entry.dof];
|
|
partition_rhs -= entry.value * initial_p_acceleration.Value()[entry.dof];
|
|
if (entry.dof % 6U < 3U) translation_sum[entry.dof % 6U] += entry.value;
|
|
}
|
|
message << "\ninitial-null row=" << row << ", node=" << node
|
|
<< ", z_label=" << chart.Value().z_dofs[row]
|
|
<< ", old_psi_a=" << original_dot
|
|
<< ", reconstructed_psi_a=" << reconstructed_dot
|
|
<< ", nH_old_a=" << projected_dot
|
|
<< ", partition_rhs=" << partition_rhs
|
|
<< ", old_r2=" << original_dot + hessian_velocity[row] +
|
|
2.0 * time_velocity + primitive.time_second;
|
|
for (std::size_t component = 0U; component < 3U; ++component) {
|
|
const auto full = 6U * node + 3U + component;
|
|
message << ", n" << component << '=' << null[component]
|
|
<< ", old_a" << component << '=' << frame.acceleration[full]
|
|
<< ", reconstructed_a" << component << '=' << reconstructed.acceleration[full]
|
|
<< ", delta_E" << component << '=' << reconstructed.residual[full] - frame.residual[full]
|
|
<< ", M_delta_a" << component << '=' << mass_delta[full]
|
|
<< ", translation_sum" << component << '=' << translation_sum[component]
|
|
<< ", nH_translation_sum" << component << '=' << projected_translation_sum[component];
|
|
}
|
|
message << ", G=";
|
|
for (std::size_t column = 0U; column < graph.Columns(); ++column)
|
|
if (graph(row, column) != 0.0)
|
|
message << '(' << column << ':' << graph(row, column) << ')';
|
|
message << ", gradient_dof_value_olda_nH=";
|
|
for (const auto& entry : primitive.gradient)
|
|
message << '(' << entry.dof << ':' << entry.value << ':'
|
|
<< frame.acceleration[entry.dof] << ':' << projected_gradient[entry.dof] << ')';
|
|
}
|
|
return Result<DynamicExecutionResult>::Failure(
|
|
Failure(domain, "dynamic-initial-consistency",
|
|
message.str()));
|
|
}
|
|
Status status = CompleteConstraintEvidence(domain, dofs, initial.Value(), length, null_nodes,
|
|
positive_solver, tangent_solver, &frame);
|
|
if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, status, "initial", 0U, 0.0));
|
|
status = CompleteEquilibrium(domain, dofs, initial.Value(), &frame);
|
|
if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(
|
|
WithProcedureContext(domain, status, "initial", 0U, 0.0));
|
|
auto graph_regularity = CheckGraphRegularity(initial.Value(), chart.Value(),
|
|
root0.Value().operators,
|
|
tangent_solver);
|
|
if (!graph_regularity.HasValue())
|
|
return Result<DynamicExecutionResult>::Failure(WithProcedureContext(
|
|
domain, graph_regularity.GetStatus(), "initial", 0U, 0.0));
|
|
if (!(frame.free_residual_metrics[0U] <= 1.0e-10 &&
|
|
frame.free_residual_metrics[1U] <= 1.0e-10))
|
|
return Result<DynamicExecutionResult>::Failure(
|
|
Failure(domain, "dynamic-initial-consistency",
|
|
"The initialized frame-zero physical residual is not acceptable."));
|
|
const double initial_energy = frame.kinetic_energy + frame.physical_strain_energy + frame.drilling_energy;
|
|
status = state.CommitAcceptedFrame(frame);
|
|
if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
|
|
DynamicNewtonIterationLogRecord record{};
|
|
record.stage = "accepted"; record.outcome = "initial"; record.correction_pass = true;
|
|
ResidualRecord(dofs, frame, &record);
|
|
status = log.Write(record); if (status.IsOk()) status = log.Flush();
|
|
if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
|
|
|
|
struct ReducedStepCandidate {
|
|
DynamicAcceptedFrameState frame;
|
|
ReducedHistory history;
|
|
};
|
|
for (std::uint32_t increment = 1U;
|
|
increment <= domain.Dynamic()->increment_count; ++increment) {
|
|
const auto& old = state.CommittedState();
|
|
const auto report_failure = [&](const Status& failure, const char* stage) {
|
|
const Status contextual = WithProcedureContext(
|
|
domain, failure, stage, increment, record.time);
|
|
record.stage = stage;
|
|
record.outcome = "failed";
|
|
record.failure_code = contextual.Diagnostics().empty()
|
|
? "dynamic-solver-failure"
|
|
: contextual.Diagnostics().front().code;
|
|
const Status written = log.Write(record);
|
|
return written.IsOk() ? contextual : written;
|
|
};
|
|
status = RunReducedHhtStep(
|
|
integrator, history, h, parameters,
|
|
[&](const ShellHhtIntegrator& step_integrator,
|
|
ReducedShellPredictor predictor) -> Result<ReducedStepCandidate> {
|
|
Vector pp = std::move(predictor.pp);
|
|
Vector vpp = std::move(predictor.vpp);
|
|
DynamicAcceptedFrameState trial_frame = old;
|
|
trial_frame.is_initial = false;
|
|
trial_frame.frame_index = increment;
|
|
trial_frame.increment_index = increment;
|
|
trial_frame.time = static_cast<double>(increment) * h;
|
|
trial_frame.time_integration_formulation =
|
|
DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
|
|
Vector trial_algorithmic{history.p.Size()};
|
|
Vector trial_p = pp;
|
|
Vector coordinate_low = std::move(predictor.coordinate_low);
|
|
Vector chosen_start_p = pp;
|
|
Vector increment_trace = std::move(predictor.increment_trace);
|
|
Vector increment_trace_compensation =
|
|
std::move(predictor.increment_trace_compensation);
|
|
Vector increment_trace_absolute_sum =
|
|
std::move(predictor.increment_trace_absolute_sum);
|
|
Vector seed = history.z;
|
|
record = {};
|
|
record.increment_index = increment;
|
|
record.time = trial_frame.time;
|
|
record.correction_pass = true;
|
|
bool translation_private_algorithmic_pass = true;
|
|
bool copy_translation_rates = false;
|
|
Vector retained_velocity{history.p.Size()};
|
|
Vector retained_acceleration{history.p.Size()};
|
|
using StepResult = Result<std::optional<ReducedStepCandidate>>;
|
|
const auto write_iteration =
|
|
[&](const DynamicNewtonIterationLogRecord& value) {
|
|
return log.Write(value);
|
|
};
|
|
ReducedShellHhtStep<ReducedStepCandidate> iteration_step(
|
|
[&](std::uint32_t iteration) -> StepResult {
|
|
record.iteration_index = iteration;
|
|
record.stage = "evaluation";
|
|
record.outcome = "candidate";
|
|
const auto fail = [&](const Status& failure,
|
|
const char* stage = "outer") -> StepResult {
|
|
return StepResult::Failure(report_failure(failure, stage));
|
|
};
|
|
ReducedShellTrialRates reduced_rates{
|
|
Vector{history.p.Size()}, Vector{history.p.Size()}};
|
|
step_integrator.EvaluateRates(
|
|
{chart.Value(), history, trial_algorithmic, vpp,
|
|
copy_translation_rates, retained_velocity, retained_acceleration,
|
|
h, parameters}, reduced_rates.velocity,
|
|
reduced_rates.acceleration);
|
|
Vector trial_v = std::move(reduced_rates.velocity);
|
|
Vector trial_a = std::move(reduced_rates.acceleration);
|
|
const auto evaluate_trial =
|
|
[&](const Vector& physical_p, const Vector& physical_v,
|
|
const Vector& physical_a,
|
|
const Vector& root_seed) -> Result<Trial> {
|
|
auto root = SolveEmbeddingRoot(
|
|
chart.Value(), physical_p, root_seed,
|
|
[&](const Vector& q) {
|
|
return position_operators(trial_frame, q);
|
|
},
|
|
tangent_solver);
|
|
if (!root.HasValue())
|
|
return Result<Trial>::Failure(WithProcedureContext(
|
|
domain, root.GetStatus(), "inner-position", increment,
|
|
trial_frame.time));
|
|
auto rates = step_integrator.ReconstructPhysicalRates(
|
|
chart.Value(), root.Value(), physical_v, physical_a,
|
|
tangent_solver);
|
|
if (!rates.HasValue())
|
|
return Result<Trial>::Failure(
|
|
WithProcedureContext(domain, rates.GetStatus(), "inner-rates",
|
|
increment, trial_frame.time));
|
|
auto candidate = trial_frame;
|
|
candidate.generalized_coordinates = root.Value().q;
|
|
candidate.velocity = rates.Value().velocity;
|
|
candidate.acceleration = rates.Value().acceleration;
|
|
candidate.algorithmic_acceleration = Vector(dofs.FullDofCount());
|
|
for (std::size_t i = 0U;
|
|
i < candidate.algorithmic_acceleration.Size(); ++i)
|
|
candidate.algorithmic_acceleration[i] =
|
|
(1.0 + parameters.alpha) * candidate.acceleration[i] -
|
|
parameters.alpha * old.acceleration[i];
|
|
candidate.iteration_count = iteration;
|
|
auto assembly = EvaluateAssembly(domain, dofs, shells.Value(),
|
|
candidate, loads.Value()[1U], h,
|
|
parameters, parallel_for, true);
|
|
if (!assembly.HasValue())
|
|
return Result<Trial>::Failure(
|
|
WithProcedureContext(domain, assembly.GetStatus(), "outer",
|
|
increment, trial_frame.time));
|
|
assembly.Value().frame.time_integration_formulation =
|
|
DynamicTimeIntegrationFormulation::kReducedCoordinateHht;
|
|
return Result<Trial>::Success(
|
|
{std::move(assembly.Value()), std::move(root.Value()),
|
|
physical_p, physical_v, physical_a, trial_algorithmic,
|
|
std::move(rates.Value().z_velocity),
|
|
std::move(rates.Value().z_acceleration)});
|
|
};
|
|
position_geometry_failure = false;
|
|
auto trial = evaluate_trial(trial_p, trial_v, trial_a, seed);
|
|
if (!trial.HasValue() && iteration == 0U &&
|
|
position_geometry_failure) {
|
|
for (std::size_t i = 0U; i < trial_p.Size(); ++i) {
|
|
trial_algorithmic[i] =
|
|
(history.p[i] - pp[i]) / (parameters.beta * h * h);
|
|
trial_p[i] = history.p[i];
|
|
chosen_start_p[i] = history.p[i];
|
|
coordinate_low[i] = 0.0;
|
|
increment_trace[i] = 0.0;
|
|
increment_trace_compensation[i] = 0.0;
|
|
increment_trace_absolute_sum[i] = 0.0;
|
|
}
|
|
step_integrator.EvaluateRates(
|
|
{chart.Value(), history, trial_algorithmic, vpp, false,
|
|
retained_velocity, retained_acceleration, h, parameters},
|
|
trial_v, trial_a);
|
|
trial = evaluate_trial(trial_p, trial_v, trial_a, seed);
|
|
}
|
|
if (!trial.HasValue())
|
|
return fail(trial.GetStatus());
|
|
if (iteration == 0U && !ExactlyEqual(trial_p, history.p)) {
|
|
Vector old_algorithmic{trial_p.Size()};
|
|
Vector old_velocity{trial_p.Size()};
|
|
Vector old_acceleration{trial_p.Size()};
|
|
for (std::size_t i = 0U; i < trial_p.Size(); ++i) {
|
|
old_algorithmic[i] =
|
|
(history.p[i] - pp[i]) / (parameters.beta * h * h);
|
|
}
|
|
step_integrator.EvaluateRates(
|
|
{chart.Value(), history, old_algorithmic, vpp, false,
|
|
retained_velocity, retained_acceleration, h, parameters},
|
|
old_velocity, old_acceleration);
|
|
auto old_trial =
|
|
evaluate_trial(history.p, old_velocity, old_acceleration, seed);
|
|
if (!old_trial.HasValue())
|
|
return fail(old_trial.GetStatus());
|
|
const auto reduced_residual = [&](const Trial& value) {
|
|
double norm = 0.0;
|
|
for (const auto full : dofs.FreeDofs()) {
|
|
const double scale = full % 6U < 3U ? length : 1.0;
|
|
norm = (std::max)(norm,
|
|
scale *
|
|
std::abs(
|
|
value.assembly.frame.residual[full]));
|
|
}
|
|
if (!std::isfinite(norm))
|
|
return std::numeric_limits<double>::infinity();
|
|
return norm;
|
|
};
|
|
const double old_residual = reduced_residual(old_trial.Value());
|
|
const double predictor_residual = reduced_residual(trial.Value());
|
|
if (!std::isfinite(old_residual) ||
|
|
!std::isfinite(predictor_residual))
|
|
return fail(
|
|
Failure(domain, "dynamic-invalid-state",
|
|
"The scaled initial reduced residual is nonfinite."));
|
|
if (old_residual < predictor_residual) {
|
|
trial = std::move(old_trial);
|
|
trial_p = history.p;
|
|
chosen_start_p = history.p;
|
|
coordinate_low = Vector(history.p.Size());
|
|
increment_trace = Vector(history.p.Size());
|
|
increment_trace_compensation = Vector(history.p.Size());
|
|
increment_trace_absolute_sum = Vector(history.p.Size());
|
|
trial_v = old_velocity;
|
|
trial_a = old_acceleration;
|
|
trial_algorithmic = old_algorithmic;
|
|
}
|
|
}
|
|
auto candidate = trial.Value().assembly.frame;
|
|
auto operators = EvaluateConstraintOperators(
|
|
domain, dofs, shells.Value(), trial.Value().assembly,
|
|
chart.Value(), zero, zero);
|
|
if (!operators.HasValue())
|
|
return fail(operators.GetStatus());
|
|
ResidualRecord(dofs, candidate, &record);
|
|
if (record.residual_pass && record.correction_pass) {
|
|
status = CompleteConstraintEvidence(
|
|
domain, dofs, trial.Value().assembly, length, null_nodes,
|
|
positive_solver, tangent_solver, &candidate);
|
|
if (!status.IsOk())
|
|
return fail(status, "accepted");
|
|
status = CompleteEquilibrium(domain, dofs, trial.Value().assembly,
|
|
&candidate);
|
|
if (!status.IsOk())
|
|
return fail(status, "accepted");
|
|
graph_regularity =
|
|
CheckGraphRegularity(trial.Value().assembly, chart.Value(),
|
|
operators.Value(), tangent_solver);
|
|
if (!graph_regularity.HasValue())
|
|
return fail(graph_regularity.GetStatus(), "accepted");
|
|
status = CheckReducedUpdates(
|
|
domain, old, candidate, pp, vpp, trial_p, trial_v, trial_a,
|
|
trial.Value().root.z, trial.Value().algebraic_velocity,
|
|
trial.Value().algebraic_acceleration, trial_algorithmic,
|
|
history.p, history.velocity, history.acceleration,
|
|
history.algorithmic_acceleration, increment_trace,
|
|
increment_trace_compensation, increment_trace_absolute_sum,
|
|
chart.Value(), chosen_start_p, coordinate_low, parameters, h);
|
|
if (!status.IsOk())
|
|
return fail(status, "accepted");
|
|
candidate.external_work = 0.0;
|
|
for (std::size_t i = 0U; i < dofs.FullDofCount(); ++i)
|
|
candidate.external_work += candidate.external_force[i] *
|
|
candidate.generalized_coordinates[i];
|
|
candidate.energy_defect = candidate.kinetic_energy +
|
|
candidate.physical_strain_energy +
|
|
candidate.drilling_energy -
|
|
initial_energy - candidate.external_work;
|
|
return StepResult::Success(ReducedStepCandidate{
|
|
std::move(candidate),
|
|
{trial_p, trial_v, trial_a, trial_algorithmic,
|
|
trial.Value().root.z}});
|
|
}
|
|
if (!CanApplyOuterCorrection(iteration)) {
|
|
double full_hidden = 0.0;
|
|
double analytic_hidden = 0.0;
|
|
double inertia_hidden = 0.0;
|
|
double consistency = 0.0;
|
|
for (std::size_t row = 0U; row < chart.Value().null_nodes.size();
|
|
++row) {
|
|
const auto node = chart.Value().null_nodes[row];
|
|
const auto& null =
|
|
trial.Value().assembly.rotations[node].drill_null;
|
|
double full = 0.0;
|
|
double inertia = 0.0;
|
|
for (std::size_t component = 0U; component < 3U; ++component) {
|
|
const auto full_dof = 6U * node + 3U + component;
|
|
full += null[component] * candidate.residual[full_dof];
|
|
inertia += null[component] * candidate.inertia_force[full_dof];
|
|
}
|
|
const double analytic = operators.Value().rows[row].value;
|
|
full_hidden = (std::max)(full_hidden, std::abs(full));
|
|
analytic_hidden = (std::max)(analytic_hidden, std::abs(analytic));
|
|
inertia_hidden = (std::max)(inertia_hidden, std::abs(inertia));
|
|
consistency =
|
|
(std::max)(consistency, std::abs(full - analytic - inertia));
|
|
}
|
|
std::ostringstream message;
|
|
const auto maximum = [](const Vector& values) {
|
|
double result = 0.0;
|
|
for (std::size_t i = 0U; i < values.Size(); ++i)
|
|
result = (std::max)(result, std::abs(values[i]));
|
|
return result;
|
|
};
|
|
Vector position_correction{trial_algorithmic.Size()};
|
|
Vector velocity_correction{trial_algorithmic.Size()};
|
|
for (std::size_t i = 0U; i < trial_algorithmic.Size(); ++i) {
|
|
position_correction[i] =
|
|
parameters.beta * h * h * trial_algorithmic[i];
|
|
velocity_correction[i] =
|
|
parameters.gamma * h * trial_algorithmic[i];
|
|
}
|
|
message << "HHT exhausted 100 corrections without satisfying every "
|
|
"endpoint check; "
|
|
<< "stage=outer, outer_iteration=" << iteration
|
|
<< ", graph_iteration="
|
|
<< trial.Value().root.graph_iteration_count
|
|
<< ", graph_residual="
|
|
<< trial.Value().root.graph_residual_infinity
|
|
<< ", graph_relative="
|
|
<< trial.Value().root.graph_residual_relative
|
|
<< ", graph_correction="
|
|
<< trial.Value().root.graph_correction_infinity
|
|
<< ", max_NtE=" << full_hidden
|
|
<< ", max_analytic_psi=" << analytic_hidden
|
|
<< ", max_NtInertia=" << inertia_hidden
|
|
<< ", max_NtE_minus_psi_minus_NtInertia=" << consistency
|
|
<< ", max_pp=" << maximum(pp)
|
|
<< ", max_beta_h2_trial_Ar=" << maximum(position_correction)
|
|
<< ", max_trial_p=" << maximum(trial_p)
|
|
<< ", max_vp_predictor=" << maximum(vpp)
|
|
<< ", max_gamma_h_trial_Ar=" << maximum(velocity_correction)
|
|
<< ", max_trial_v=" << maximum(trial_v)
|
|
<< ", max_physical_v=" << maximum(trial.Value().velocity)
|
|
<< ".";
|
|
return fail(
|
|
Failure(domain, "dynamic-nonconvergence", message.str()));
|
|
}
|
|
status = write_iteration(record);
|
|
if (!status.IsOk())
|
|
return StepResult::Failure(status);
|
|
const double velocity_rate = parameters.gamma / (parameters.beta * h);
|
|
const double acceleration_rate =
|
|
1.0 / ((1.0 + parameters.alpha) * parameters.beta * h * h);
|
|
auto system = AssembleAugmentedReducedSystem(
|
|
trial.Value().assembly, chart.Value(), operators.Value(),
|
|
velocity_rate, acceleration_rate, length, h);
|
|
if (!system.HasValue())
|
|
return fail(system.GetStatus());
|
|
const bool angular_only = ShouldRefineAngular(
|
|
chart.Value(), candidate.free_residual_metrics,
|
|
{record.coordinate_correction[0U], record.velocity_correction[0U],
|
|
record.acceleration_correction[0U],
|
|
record.algorithmic_correction[0U]},
|
|
translation_private_algorithmic_pass);
|
|
auto selected =
|
|
SelectAugmentedSolve(system.Value(), chart.Value(), angular_only);
|
|
if (!selected.HasValue())
|
|
return fail(selected.GetStatus());
|
|
const auto linear_failure = [&](const Status& failure) {
|
|
return fail(failure, angular_only ? "angular-newton-linear-solve"
|
|
: "full-newton-linear-solve");
|
|
};
|
|
Vector selected_solution{selected.Value().rhs.Size()};
|
|
if (selected_solution.Size() > 0U) {
|
|
status = tangent_solver.FactorizeFresh(selected.Value().tangent);
|
|
if (!status.IsOk())
|
|
return linear_failure(status);
|
|
status = tangent_solver.SolveCorrection(selected.Value().rhs,
|
|
selected_solution);
|
|
if (!status.IsOk())
|
|
return linear_failure(status);
|
|
status = CheckLinearSolve(selected.Value().tangent,
|
|
selected.Value().rhs, selected_solution);
|
|
if (!status.IsOk())
|
|
return linear_failure(status);
|
|
}
|
|
auto solution = EmbedAugmentedSolution(
|
|
selected.Value(), selected_solution, system.Value().rhs.Size());
|
|
if (!solution.HasValue())
|
|
return fail(solution.GetStatus());
|
|
auto correction = MapAugmentedCorrection(
|
|
chart.Value(), system.Value(), solution.Value(), velocity_rate,
|
|
acceleration_rate);
|
|
if (!correction.HasValue())
|
|
return fail(correction.GetStatus());
|
|
Vector full_algorithmic{dofs.FullDofCount()};
|
|
Vector reduced_algorithmic{correction.Value().p.Size()};
|
|
Vector reduced_physical{correction.Value().p.Size()};
|
|
for (std::size_t i = 0U; i < full_algorithmic.Size(); ++i)
|
|
full_algorithmic[i] =
|
|
(1.0 + parameters.alpha) * correction.Value().acceleration[i];
|
|
for (std::size_t i = 0U; i < reduced_algorithmic.Size(); ++i) {
|
|
reduced_algorithmic[i] =
|
|
correction.Value().p[i] / (parameters.beta * h * h);
|
|
reduced_physical[i] = acceleration_rate * correction.Value().p[i];
|
|
}
|
|
CorrectionRecord(correction.Value().coordinate,
|
|
correction.Value().velocity,
|
|
correction.Value().acceleration, full_algorithmic,
|
|
reduced_algorithmic, reduced_physical, chart.Value(),
|
|
dofs, length, h, parameters.alpha, &record);
|
|
translation_private_algorithmic_pass = true;
|
|
for (std::size_t i = 0U; i < chart.Value().p_dofs.size(); ++i)
|
|
if (PhysicalCoordinateChannel(chart.Value(), i) == 0U)
|
|
translation_private_algorithmic_pass =
|
|
translation_private_algorithmic_pass &&
|
|
PrivateCorrectionEqual(chart.Value(), i, full_algorithmic,
|
|
reduced_algorithmic, reduced_physical,
|
|
parameters.alpha);
|
|
copy_translation_rates = angular_only;
|
|
if (angular_only) {
|
|
retained_velocity = trial_v;
|
|
retained_acceleration = trial_a;
|
|
}
|
|
for (std::size_t i = 0U; i < trial_algorithmic.Size(); ++i) {
|
|
if (angular_only &&
|
|
PhysicalCoordinateChannel(chart.Value(), i) == 0U)
|
|
continue;
|
|
trial_algorithmic[i] += reduced_algorithmic[i];
|
|
}
|
|
for (std::size_t i = 0U; i < trial_p.Size(); ++i) {
|
|
if (angular_only &&
|
|
PhysicalCoordinateChannel(chart.Value(), i) == 0U)
|
|
continue;
|
|
AdvanceCoordinate(correction.Value().p[i], &trial_p[i],
|
|
&coordinate_low[i]);
|
|
}
|
|
for (std::size_t i = 0U; i < increment_trace.Size(); ++i) {
|
|
if (angular_only &&
|
|
PhysicalCoordinateChannel(chart.Value(), i) == 0U)
|
|
continue;
|
|
AddIncrementTraceTerm(correction.Value().p[i], &increment_trace[i],
|
|
&increment_trace_compensation[i]);
|
|
increment_trace_absolute_sum[i] +=
|
|
std::abs(correction.Value().p[i]);
|
|
}
|
|
seed = trial.Value().root.z;
|
|
for (std::size_t i = 0U; i < seed.Size(); ++i)
|
|
seed[i] += correction.Value().z[i];
|
|
return StepResult::Success(std::nullopt);
|
|
},
|
|
kMaximumOuterCorrections);
|
|
const Status solved = iteration_step.Solve(algorithm);
|
|
if (!solved.IsOk())
|
|
return Result<ReducedStepCandidate>::Failure(solved);
|
|
if (!iteration_step.HasCandidate()) return Result<ReducedStepCandidate>::Failure(
|
|
Failure(domain, "dynamic-nonconvergence", "Dynamic increment was not accepted."));
|
|
return Result<ReducedStepCandidate>::Success(
|
|
iteration_step.TakeCandidate());
|
|
},
|
|
[&](ReducedStepCandidate&& accepted_candidate) -> Status {
|
|
status = state.CommitAcceptedFrame(accepted_candidate.frame);
|
|
if (!status.IsOk())
|
|
return report_failure(status, "accepted");
|
|
history = std::move(accepted_candidate.history);
|
|
record.stage = "accepted";
|
|
record.outcome = "accepted";
|
|
status = log.Write(record);
|
|
if (status.IsOk())
|
|
status = log.Flush();
|
|
return status;
|
|
});
|
|
if (!status.IsOk()) return Result<DynamicExecutionResult>::Failure(status);
|
|
}
|
|
return Result<DynamicExecutionResult>::Success(
|
|
{std::move(state), domain.Warnings()});
|
|
}
|
|
} // namespace fesa
|