KOKO\Mimi
1142 lines
51 KiB
C++
1142 lines
51 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "analysis/thermal_transient_algebra.h"
|
|
#include "fesa/analysis/transient_heat_procedure.h"
|
|
#include "fesa/solvers/linear/mkl_pardiso_solver.h"
|
|
#include "thermal_gauss_oracle.h"
|
|
#include "thermal_slab_oracle.h"
|
|
|
|
#include "fesa/assembly/thermal_assembler.h"
|
|
|
|
namespace {
|
|
namespace ti = fesa::thermal_transient_internal;
|
|
using fesa::Vector;
|
|
using fesa::Vector3;
|
|
|
|
// Independent test arithmetic: outward endpoints after each scalar operation.
|
|
// No production interval, kernel, transcendental, or tolerance helper is used
|
|
// to construct the analytical expectations.
|
|
double Down(double x) {
|
|
return std::nextafter(x, -std::numeric_limits<double>::infinity());
|
|
}
|
|
double Up(double x) {
|
|
return std::nextafter(x, std::numeric_limits<double>::infinity());
|
|
}
|
|
struct I {
|
|
double lo, hi;
|
|
I(double x = 0) : lo(x), hi(x) {}
|
|
I(double lo, double hi) : lo(lo), hi(hi) {}
|
|
double Mid() const { return lo + (hi - lo) * .5; }
|
|
double Abs() const { return std::max(std::abs(lo), std::abs(hi)); }
|
|
};
|
|
I operator+(I a, I b) {
|
|
if (a.lo == 0 && a.hi == 0) return b;
|
|
if (b.lo == 0 && b.hi == 0) return a;
|
|
return {Down(a.lo + b.lo), Up(a.hi + b.hi)};
|
|
}
|
|
I operator-(I a, I b) { return a + I{-b.hi, -b.lo}; }
|
|
I operator*(I a, I b) {
|
|
if ((a.lo == 0 && a.hi == 0) || (b.lo == 0 && b.hi == 0)) return I{0};
|
|
const std::array<double, 4> v{a.lo * b.lo, a.lo * b.hi, a.hi * b.lo,
|
|
a.hi * b.hi};
|
|
return {Down(*std::min_element(v.begin(), v.end())),
|
|
Up(*std::max_element(v.begin(), v.end()))};
|
|
}
|
|
I operator/(I a, I b) {
|
|
if (b.lo <= 0 && b.hi >= 0)
|
|
throw std::runtime_error{"Oracle division includes zero."};
|
|
return a * I{Down(1 / b.hi), Up(1 / b.lo)};
|
|
}
|
|
I Sqrt(I a) {
|
|
if (a.lo < 0)
|
|
throw std::runtime_error{"Oracle square root includes negative values."};
|
|
if (a.hi == 0) return I{0};
|
|
return {a.lo == 0 ? 0 : Down(std::sqrt(a.lo)), Up(std::sqrt(a.hi))};
|
|
}
|
|
I Square(I x) {
|
|
if (x.lo == 0 && x.hi == 0) return I{0};
|
|
const double lower =
|
|
x.lo <= 0 && x.hi >= 0 ? 0 : Down(std::min(x.lo * x.lo, x.hi * x.hi));
|
|
return {lower, Up(x.Abs() * x.Abs())};
|
|
}
|
|
I Gamma(std::size_t n) {
|
|
return (I{static_cast<double>(n)} * I{0x1p-53}) /
|
|
(I{1} - I{static_cast<double>(n)} * I{0x1p-53});
|
|
}
|
|
I Pi() {
|
|
static const I value = [] {
|
|
// Machin's formula; alternating arctan remainder after terms 0..63.
|
|
const auto atan = [](double denominator) {
|
|
const I q = I{1} / I{denominator}, q2 = q * q;
|
|
I power = q, sum;
|
|
for (int j = 0; j < 64; ++j) {
|
|
sum = sum + power / I{static_cast<double>(2 * j + 1)};
|
|
power = power * q2 * I{-1};
|
|
}
|
|
const double tail = (power / I{129}).Abs();
|
|
return sum + I{-tail, tail};
|
|
};
|
|
return I{16} * atan(5) - I{4} * atan(239);
|
|
}();
|
|
return value;
|
|
}
|
|
I Cos(I x) {
|
|
if (x.hi < 0) x = I{-x.hi, -x.lo};
|
|
if (x.lo > Pi().hi / 2) {
|
|
const auto reduced = Cos(Pi() - x);
|
|
return I{-reduced.hi, -reduced.lo};
|
|
}
|
|
// |x|<=pi<4. Thirty-two terms; the omitted absolute term bounds the
|
|
// alternating tail after decreasing terms begin. All polynomial work is
|
|
// enclosed independently of a libm accuracy assumption.
|
|
I term{1}, sum{1};
|
|
const I x2 = x * x;
|
|
for (int j = 1; j < 32; ++j) {
|
|
term = term * x2 * I{-1} / I{static_cast<double>((2 * j - 1) * 2 * j)};
|
|
sum = sum + term;
|
|
}
|
|
const double tail = (term * x2 / I{63. * 64.}).Abs();
|
|
return sum + I{-tail, tail};
|
|
}
|
|
I ExpNegative(I x) {
|
|
if (x.lo < 0) throw std::runtime_error{"Negative exponential argument."};
|
|
int squares = 0;
|
|
while (x.hi > .5) {
|
|
x = x / I{2};
|
|
++squares;
|
|
}
|
|
I term{1}, sum{1};
|
|
for (int j = 1; j <= 64; ++j) {
|
|
term = term * x * I{-1} / I{static_cast<double>(j)};
|
|
sum = sum + term;
|
|
}
|
|
const double tail = (term * x / I{65}).Abs();
|
|
sum = sum + I{-tail, tail};
|
|
for (int j = 0; j < squares; ++j) sum = sum * sum;
|
|
return sum;
|
|
}
|
|
I Power(I x, std::uint32_t n) {
|
|
I result{1};
|
|
for (; n; n >>= 1) {
|
|
if (n & 1U) result = result * x;
|
|
if (n > 1) x = x * x;
|
|
}
|
|
return result;
|
|
}
|
|
template <class T>
|
|
T Take(fesa::Result<T> r) {
|
|
if (!r.HasValue()) {
|
|
std::ostringstream text;
|
|
for (const auto& d : r.GetStatus().Diagnostics())
|
|
text << d.code << ": " << d.message << '\n';
|
|
throw std::runtime_error{text.str()};
|
|
}
|
|
return std::move(r.Value());
|
|
}
|
|
void Checked(const fesa::Status& status) {
|
|
if (!status.IsOk()) {
|
|
std::ostringstream text;
|
|
for (const auto& d : status.Diagnostics())
|
|
text << d.code << ": " << d.message << '\n';
|
|
throw std::runtime_error{text.str()};
|
|
}
|
|
}
|
|
fesa::ModelDefinition Mesh(
|
|
std::size_t n, double period, std::uint32_t count,
|
|
const std::function<double(std::size_t, std::size_t)>& initial) {
|
|
fesa::ModelDefinition m;
|
|
for (std::size_t j = 0; j <= n; ++j)
|
|
for (std::size_t i = 0; i <= n; ++i) {
|
|
const auto index = static_cast<fesa::EntityIndex>(j * (n + 1) + i);
|
|
m.nodes.push_back(
|
|
{{"plate", static_cast<std::int64_t>(index + 1),
|
|
std::to_string(index + 1)},
|
|
{static_cast<double>(i) / n, static_cast<double>(j) / n, 0},
|
|
{}});
|
|
m.thermal_initial_conditions.push_back({index, initial(i, j), {}});
|
|
}
|
|
m.thermal_materials = {{{"plate", 1, "1"}, "unit", 1, 1, 1, {}}};
|
|
m.thermal_sections = {{{"plate", 1, "1"}, "unit", 1, 0, {}}};
|
|
for (std::size_t j = 0; j < n; ++j)
|
|
for (std::size_t i = 0; i < n; ++i) {
|
|
const auto node = static_cast<fesa::EntityIndex>(j * (n + 1) + i);
|
|
const auto label = static_cast<std::int64_t>(j * n + i + 1);
|
|
m.thermal_elements.push_back(
|
|
{{"plate", label, std::to_string(label)},
|
|
{{node, node + 1, static_cast<fesa::EntityIndex>(node + n + 2),
|
|
static_cast<fesa::EntityIndex>(node + n + 1)}},
|
|
0,
|
|
{}});
|
|
}
|
|
m.thermal_step =
|
|
fesa::ThermalStepDefinition{"physics", period / count, period, count};
|
|
return m;
|
|
}
|
|
struct Prepared {
|
|
fesa::Domain domain;
|
|
fesa::AnalysisModel model;
|
|
fesa::DofManager dofs;
|
|
fesa::ThermalAssembly assembly;
|
|
fesa::ThermalAnalysisState state;
|
|
Prepared(fesa::ModelDefinition definition, const fesa::ParallelFor& parallel)
|
|
: domain(Take(fesa::Domain::Create(std::move(definition)))),
|
|
model(Take(fesa::AnalysisModel::Create(domain))),
|
|
dofs(Take(fesa::DofManager::CreateThermal(model))),
|
|
assembly(Take(fesa::AssembleThermal(model, dofs, parallel))),
|
|
state(Take(fesa::ThermalAnalysisState::Create(model, dofs, assembly))) {
|
|
}
|
|
};
|
|
struct RunMetrics {
|
|
double beta = 0, full_beta = 0, capacity_budget = 0;
|
|
double energy_defect = 0, energy_bound = 0, dissipation_defect = 0,
|
|
dissipation_bound = 0;
|
|
std::uint64_t temperature_values = 0, flux_values = 0;
|
|
std::vector<ti::ThermalStepEvidence> steps;
|
|
double last_free_residual_l1 = 0, last_free_residual_inf = 0,
|
|
last_reaction_evaluation_error = 0;
|
|
};
|
|
RunMetrics Advance(Prepared& p, const fesa::ParallelFor& parallel,
|
|
double mass_lower, double initial_capacity_budget = 0) {
|
|
fesa::MklPardisoSolver solver;
|
|
ti::ThermalFactorization cache;
|
|
ti::ThermalSystem system{
|
|
p.assembly.Conductivity(), p.assembly.Capacity(),
|
|
p.assembly.HeatInput(), &p.assembly.ConductivityError(),
|
|
&p.assembly.CapacityError(), &p.assembly.HeatInputError()};
|
|
ti::ThermalPartition partition{p.dofs.FreeDofs(), p.dofs.ConstrainedDofs(),
|
|
p.dofs.PrescribedValues()};
|
|
RunMetrics metrics;
|
|
I budget{initial_capacity_budget};
|
|
const std::uint64_t count = p.state.TimeGrid().Count();
|
|
for (std::uint64_t step = 1; step <= count; ++step) {
|
|
const auto schedule =
|
|
Take(p.state.TimeGrid().Frame(static_cast<std::uint32_t>(step)));
|
|
const auto& old = p.state.CommittedState().temperature;
|
|
auto next = Take(ti::SolveThermalIncrement(system, partition, old,
|
|
schedule.delta, solver, cache));
|
|
const auto& e = next.evidence;
|
|
metrics.steps.push_back(e);
|
|
EXPECT_LE(e.beta_cert, e.beta_limit);
|
|
EXPECT_LE(e.full_beta_cert, e.beta_limit);
|
|
EXPECT_LE(e.energy_defect, e.energy_bound);
|
|
if (e.dissipation_checked)
|
|
EXPECT_LE(e.dissipation_defect, e.dissipation_bound);
|
|
metrics.beta = std::max(metrics.beta, e.beta_cert);
|
|
metrics.full_beta = std::max(metrics.full_beta, e.full_beta_cert);
|
|
metrics.energy_defect = std::max(metrics.energy_defect, e.energy_defect);
|
|
metrics.energy_bound = std::max(metrics.energy_bound, e.energy_bound);
|
|
metrics.dissipation_defect =
|
|
std::max(metrics.dissipation_defect, e.dissipation_defect);
|
|
metrics.dissipation_bound =
|
|
std::max(metrics.dissipation_bound, e.dissipation_bound);
|
|
I residual_square;
|
|
for (auto row : partition.free)
|
|
residual_square =
|
|
residual_square + Square(I{next.certified_residual[row]});
|
|
// Approved contraction for structured homogeneous error, using observed
|
|
// component residual enclosures including E_C/E_K, never beta_limit.
|
|
budget = budget +
|
|
I{schedule.delta} * Sqrt(residual_square) / Sqrt(I{mass_lower});
|
|
if (step == count) {
|
|
I free_l1, reaction_error;
|
|
for (auto row : partition.free) {
|
|
free_l1 = free_l1 + I{next.certified_residual[row]};
|
|
metrics.last_free_residual_inf = std::max(
|
|
metrics.last_free_residual_inf, next.certified_residual[row]);
|
|
}
|
|
for (std::size_t c = 0; c < partition.constrained.size(); ++c) {
|
|
const auto row = partition.constrained[c];
|
|
I residual = I{-system.q[row]};
|
|
for (auto entry = system.c.RowOffsets()[row];
|
|
entry < system.c.RowOffsets()[row + 1]; ++entry) {
|
|
const auto col = system.c.ColumnIndices()[entry];
|
|
const I capacity =
|
|
I{system.c.Values()[entry]} + I{-system.c_error->Values()[entry],
|
|
system.c_error->Values()[entry]};
|
|
const I conductivity =
|
|
I{system.k.Values()[entry]} + I{-system.k_error->Values()[entry],
|
|
system.k_error->Values()[entry]};
|
|
residual = residual +
|
|
capacity * ((I{next.temperature[col]} - I{old[col]}) /
|
|
I{schedule.delta}) +
|
|
conductivity * I{next.temperature[col]};
|
|
}
|
|
residual =
|
|
residual + I{-(*system.q_error)[row], (*system.q_error)[row]};
|
|
reaction_error =
|
|
reaction_error + I{(residual - I{next.reaction[c]}).Abs()};
|
|
}
|
|
metrics.last_free_residual_l1 = free_l1.hi;
|
|
metrics.last_reaction_evaluation_error = reaction_error.hi;
|
|
}
|
|
auto flux = Take(p.assembly.RecoverFlux(next.temperature, parallel));
|
|
auto frame = Take(p.state.MakeCompletedFrame(
|
|
static_cast<std::uint32_t>(step), std::move(next.temperature),
|
|
std::move(next.reaction), std::move(flux)));
|
|
Checked(p.state.CommitAcceptedFrame(frame));
|
|
}
|
|
metrics.capacity_budget = budget.hi;
|
|
EXPECT_TRUE(p.state.IsComplete());
|
|
EXPECT_EQ(p.state.AcceptedFrames().size(), count + 1);
|
|
EXPECT_FALSE(p.state.AcceptedFrames()[0].completed.has_value());
|
|
for (const auto& frame : p.state.AcceptedFrames()) {
|
|
metrics.temperature_values += frame.temperature.Size();
|
|
if (frame.completed)
|
|
metrics.flux_values += frame.completed->global_heat_flux.size() * 72U;
|
|
}
|
|
return metrics;
|
|
}
|
|
void Print(const char* name, std::size_t mesh, std::uint32_t count,
|
|
const RunMetrics& m) {
|
|
std::cout << std::setprecision(17) << "THERMAL_PHYSICS case=" << name
|
|
<< " n=" << mesh << " steps=" << count << " beta=" << m.beta
|
|
<< " physical_beta=" << m.full_beta
|
|
<< " capacity_budget=" << m.capacity_budget
|
|
<< " energy_defect=" << m.energy_defect
|
|
<< " energy_bound=" << m.energy_bound
|
|
<< " dissipation_defect=" << m.dissipation_defect
|
|
<< " dissipation_bound=" << m.dissipation_bound
|
|
<< " temperature_values=" << m.temperature_values
|
|
<< " flux_values=" << m.flux_values << '\n';
|
|
}
|
|
// Exact tensor mass independently assembled from the rational Q1 and P2
|
|
// element integrals. This checks actual 2-D nodal/station vectors.
|
|
I CapacityNorm(const Vector& values, std::size_t n) {
|
|
constexpr int q[4][4] = {
|
|
{4, 2, 1, 2}, {2, 4, 2, 1}, {1, 2, 4, 2}, {2, 1, 2, 4}};
|
|
constexpr int z[3][3] = {{4, 2, -1}, {2, 16, 2}, {-1, 2, 4}};
|
|
I sum;
|
|
for (std::size_t y = 0; y < n; ++y)
|
|
for (std::size_t x = 0; x < n; ++x) {
|
|
const std::size_t a = y * (n + 1) + x;
|
|
const std::array<std::size_t, 4> nodes{a, a + 1, a + n + 2, a + n + 1};
|
|
for (std::size_t i = 0; i < 4; ++i)
|
|
for (std::size_t j = 0; j < 4; ++j)
|
|
for (std::size_t segment = 0; segment < 2; ++segment)
|
|
for (std::size_t u = 0; u < 3; ++u)
|
|
for (std::size_t v = 0; v < 3; ++v)
|
|
sum = sum + I{values[5 * nodes[i] + 2 * segment + u]} *
|
|
I{values[5 * nodes[j] + 2 * segment + v]} *
|
|
(I{static_cast<double>(q[i][j] * z[u][v])} /
|
|
I{2160. * n * n});
|
|
}
|
|
return Sqrt(sum);
|
|
}
|
|
TEST(ThermalPhysics, InsulatedUniformAndZeroRetainAllFramesWithConservation) {
|
|
fesa::SerialParallelFor parallel;
|
|
for (double temperature : {0., 2., -2.}) {
|
|
Prepared p{Mesh(2, .25, 8, [&](auto, auto) { return temperature; }),
|
|
parallel};
|
|
const auto metrics = Advance(p, parallel, Down(1. / 8640));
|
|
Print("uniform", 2, 8, metrics);
|
|
const double bound = (I{metrics.capacity_budget} / Sqrt(I{1. / 8640})).hi;
|
|
for (const auto& frame : p.state.AcceptedFrames())
|
|
for (std::size_t i = 0; i < frame.temperature.Size(); ++i)
|
|
EXPECT_LE(std::abs(frame.temperature[i] - temperature), bound);
|
|
if (temperature == 0) {
|
|
EXPECT_EQ(metrics.capacity_budget, 0);
|
|
EXPECT_EQ(metrics.energy_defect, 0);
|
|
EXPECT_EQ(metrics.dissipation_defect, 0);
|
|
}
|
|
EXPECT_EQ(metrics.flux_values, 8U * 4U * 72U);
|
|
}
|
|
}
|
|
void VerifyDiscreteEigenmode(const Prepared& p, const std::array<I, 9>& mode,
|
|
I lambda) {
|
|
constexpr int mass[4][4] = {
|
|
{4, 2, 1, 2}, {2, 4, 2, 1}, {1, 2, 4, 2}, {2, 1, 2, 4}};
|
|
constexpr int stiffness[4][4] = {
|
|
{4, -1, -2, -1}, {-1, 4, -1, -2}, {-2, -1, 4, -1}, {-1, -2, -1, 4}};
|
|
constexpr int z_mass[3][3] = {{4, 2, -1}, {2, 16, 2}, {-1, 2, 4}};
|
|
constexpr int z_stiffness[3][3] = {{7, -8, 1}, {-8, 16, -8}, {1, -8, 7}};
|
|
std::array<I, 405> cv{}, kv{};
|
|
for (std::size_t y = 0; y < 8; ++y)
|
|
for (std::size_t x = 0; x < 8; ++x) {
|
|
const auto node = y * 9 + x;
|
|
const std::array<std::size_t, 4> nodes{node, node + 1, node + 10,
|
|
node + 9};
|
|
for (std::size_t i = 0; i < 4; ++i)
|
|
for (std::size_t j = 0; j < 4; ++j)
|
|
for (std::size_t segment = 0; segment < 2; ++segment)
|
|
for (std::size_t a = 0; a < 3; ++a)
|
|
for (std::size_t b = 0; b < 3; ++b) {
|
|
const auto row = 5 * nodes[i] + 2 * segment + a;
|
|
const I m = I{static_cast<double>(mass[i][j])} / I{36 * 64.};
|
|
const I s = I{static_cast<double>(stiffness[i][j])} / I{6};
|
|
const I c = I{static_cast<double>(z_mass[a][b])} / I{60};
|
|
const I k = I{2. * z_stiffness[a][b]} / I{3};
|
|
cv[row] = cv[row] + m * c * mode[nodes[j] % 9];
|
|
kv[row] = kv[row] + (s * c + m * k) * mode[nodes[j] % 9];
|
|
}
|
|
}
|
|
const auto& c = p.assembly.Capacity();
|
|
const auto& k = p.assembly.Conductivity();
|
|
I independent_norm, actual_norm;
|
|
double residual_bound = 0;
|
|
const auto intersects = [](I a, I b) {
|
|
EXPECT_LE(std::max(a.lo, b.lo), std::min(a.hi, b.hi));
|
|
};
|
|
for (std::size_t row = 0; row < 405; ++row) {
|
|
I actual_c, actual_k;
|
|
for (auto entry = c.RowOffsets()[row]; entry < c.RowOffsets()[row + 1];
|
|
++entry) {
|
|
const I v = mode[(c.ColumnIndices()[entry] / 5) % 9];
|
|
actual_c = actual_c + (I{c.Values()[entry]} +
|
|
I{-p.assembly.CapacityError().Values()[entry],
|
|
p.assembly.CapacityError().Values()[entry]}) *
|
|
v;
|
|
actual_k =
|
|
actual_k + (I{k.Values()[entry]} +
|
|
I{-p.assembly.ConductivityError().Values()[entry],
|
|
p.assembly.ConductivityError().Values()[entry]}) *
|
|
v;
|
|
}
|
|
intersects(actual_c, cv[row]);
|
|
intersects(actual_k, kv[row]);
|
|
const I residual = kv[row] - lambda * cv[row];
|
|
EXPECT_LE(residual.lo, 0);
|
|
EXPECT_GE(residual.hi, 0);
|
|
const I assembled_residual = actual_k - lambda * actual_c;
|
|
EXPECT_LE(assembled_residual.lo, 0);
|
|
EXPECT_GE(assembled_residual.hi, 0);
|
|
residual_bound = std::max(residual_bound, assembled_residual.Abs());
|
|
independent_norm = independent_norm + mode[(row / 5) % 9] * cv[row];
|
|
actual_norm = actual_norm + mode[(row / 5) % 9] * actual_c;
|
|
}
|
|
const I analytical_norm = (I{2} + mode[1]) / I{6};
|
|
intersects(independent_norm, analytical_norm);
|
|
intersects(actual_norm, analytical_norm);
|
|
const I normalized = actual_norm / analytical_norm;
|
|
EXPECT_LE(normalized.lo, 1);
|
|
EXPECT_GE(normalized.hi, 1);
|
|
std::cout << std::setprecision(17)
|
|
<< "THERMAL_EIGENMODE residual_bound=" << residual_bound
|
|
<< " C_norm_squared_lower=" << actual_norm.lo
|
|
<< " C_norm_squared_upper=" << actual_norm.hi
|
|
<< " normalized_lower=" << normalized.lo
|
|
<< " normalized_upper=" << normalized.hi << '\n';
|
|
}
|
|
TEST(ThermalPhysics, DiscreteEigenmodeHasFirstOrderTimeConvergence) {
|
|
fesa::SerialParallelFor parallel;
|
|
std::array<I, 9> cosines;
|
|
double initial_error = 0;
|
|
for (std::size_t i = 0; i < cosines.size(); ++i) {
|
|
cosines[i] = Cos(Pi() * I{static_cast<double>(i)} / I{8});
|
|
initial_error =
|
|
std::max(initial_error, (cosines[i] - I{cosines[i].Mid()}).Abs());
|
|
}
|
|
const I lambda = I{384} * (I{1} - cosines[1]) / (I{2} + cosines[1]);
|
|
const double period = (I{1} / lambda).Mid();
|
|
const I exact = ExpNegative(lambda * I{period});
|
|
double previous_error = 0;
|
|
for (std::uint32_t count : {16U, 32U, 64U, 128U, 256U}) {
|
|
Prepared p{Mesh(8, period, count,
|
|
[&](std::size_t i, auto) { return cosines[i].Mid(); }),
|
|
parallel};
|
|
if (count == 16) VerifyDiscreteEigenmode(p, cosines, lambda);
|
|
const auto metrics =
|
|
Advance(p, parallel, Down(1. / (2160 * 64)), initial_error);
|
|
const auto& actual = p.state.CommittedState().temperature;
|
|
Vector error{actual.Size()}, mode{actual.Size()}, difference{actual.Size()};
|
|
const I be = Power(I{1} / (I{1} + lambda * I{period / count}), count);
|
|
double oracle_width = 0;
|
|
for (std::size_t node = 0; node < 81; ++node)
|
|
for (std::size_t a = 0; a < 5; ++a) {
|
|
const auto i = node % 9;
|
|
const I v = cosines[i] * exact, expected = cosines[i] * be;
|
|
error[5 * node + a] = actual[5 * node + a] - v.Mid();
|
|
mode[5 * node + a] = cosines[i].Mid();
|
|
difference[5 * node + a] = actual[5 * node + a] - expected.Mid();
|
|
oracle_width =
|
|
std::max(oracle_width, (expected - I{expected.Mid()}).Abs());
|
|
}
|
|
const I mode_norm = CapacityNorm(mode, 8);
|
|
const I error_norm = CapacityNorm(error, 8) / mode_norm;
|
|
const I agreement = CapacityNorm(difference, 8);
|
|
const I total_budget = I{metrics.capacity_budget} + I{oracle_width};
|
|
EXPECT_LE(agreement.hi, total_budget.hi);
|
|
EXPECT_LE((total_budget / mode_norm).hi, error_norm.lo / 1000);
|
|
if (previous_error > 0) {
|
|
const double order = std::log2(previous_error / error_norm.Mid());
|
|
EXPECT_GE(order, .97);
|
|
EXPECT_LE(order, 1.02);
|
|
std::cout << std::setprecision(17) << "THERMAL_TIME N=" << count
|
|
<< " error=" << error_norm.Mid() << " order=" << order
|
|
<< " oracle_width=" << oracle_width << '\n';
|
|
}
|
|
previous_error = error_norm.Mid();
|
|
Print("time", 8, count, metrics);
|
|
}
|
|
}
|
|
|
|
TEST(ThermalPhysics, SignedOverlappingAndConstrainedPowerBalanceByComponent) {
|
|
fesa::SerialParallelFor parallel;
|
|
auto definition = Mesh(1, .5, 8, [](auto, auto) { return 0.; });
|
|
for (fesa::EntityIndex i = 0; i < 4; ++i) {
|
|
auto node = definition.nodes[i];
|
|
node.source_id.instance_name = "other";
|
|
node.coordinates[0] += 3;
|
|
definition.nodes.push_back(node);
|
|
definition.thermal_initial_conditions.push_back({i + 4, 0, {}});
|
|
}
|
|
definition.thermal_elements.push_back(
|
|
{{"other", 1, "1"}, {{4, 5, 7, 6}}, 0, {}});
|
|
definition.thermal_model_boundaries = {{0, 11, 0, {}}};
|
|
definition.thermal_step->loads = {{0, 11, 3, {}, 0},
|
|
{1, 15, -3, {}, 1},
|
|
{4, 11, 2, {}, 2},
|
|
{4, 11, 3, {}, 3},
|
|
{6, 15, -5, {}, 4}};
|
|
auto without_constrained = definition;
|
|
without_constrained.thermal_step->loads.erase(
|
|
without_constrained.thermal_step->loads.begin());
|
|
Prepared p{std::move(definition), parallel},
|
|
other{std::move(without_constrained), parallel};
|
|
EXPECT_EQ(p.assembly.HeatInput()[20], 5);
|
|
EXPECT_EQ(p.assembly.HeatInput()[34], -5);
|
|
const auto metrics = Advance(p, parallel, Down(1. / 2160));
|
|
const auto other_metrics = Advance(other, parallel, Down(1. / 2160));
|
|
Print("signed-component", 1, 8, metrics);
|
|
Print("without-constrained-power", 1, 8, other_metrics);
|
|
const std::array<I, 5> weights{I{1} / I{48}, I{1} / I{12}, I{1} / I{24},
|
|
I{1} / I{12}, I{1} / I{48}};
|
|
for (std::size_t step = 1; step < p.state.AcceptedFrames().size(); ++step) {
|
|
const auto& frame = p.state.AcceptedFrames()[step];
|
|
const auto& old = p.state.AcceptedFrames()[step - 1];
|
|
const auto& other_frame = other.state.AcceptedFrames()[step];
|
|
std::array<I, 2> energy;
|
|
for (std::size_t i = 0; i < 40; ++i) {
|
|
energy[i / 20] =
|
|
energy[i / 20] +
|
|
weights[i % 5] * (I{frame.temperature[i]} - I{old.temperature[i]});
|
|
EXPECT_DOUBLE_EQ(frame.temperature[i], other_frame.temperature[i]);
|
|
}
|
|
const double reaction = frame.completed->reaction_heat_rate[0];
|
|
const I first = energy[0] - I{frame.time_increment} * I{reaction};
|
|
// Independent exact unit-volume quadrature and component inventory.
|
|
EXPECT_LE(first.Abs(), metrics.steps[step - 1].energy_bound);
|
|
EXPECT_LE(energy[1].Abs(), metrics.steps[step - 1].energy_bound);
|
|
const double other_reaction = other_frame.completed->reaction_heat_rate[0];
|
|
const I reaction_shift = I{reaction} - I{other_reaction} + I{3};
|
|
const I subtraction =
|
|
Gamma(4) * (I{std::abs(reaction)} + I{std::abs(other_reaction)} + I{3});
|
|
EXPECT_LE(reaction_shift.Abs(), subtraction.hi);
|
|
}
|
|
}
|
|
|
|
fesa::SparseMatrix ZeroLike(const fesa::SparseMatrix& a) {
|
|
std::vector<fesa::CooContribution> coo;
|
|
for (std::size_t i = 0; i < a.Rows(); ++i)
|
|
for (std::size_t j = a.RowOffsets()[i]; j < a.RowOffsets()[i + 1]; ++j)
|
|
coo.push_back({i, a.ColumnIndices()[j], 0, 0, j});
|
|
return Take(fesa::SparseMatrix::FromCoo(a.Rows(), a.Columns(), std::move(coo),
|
|
{a.RowOffsets(), a.ColumnIndices()}));
|
|
}
|
|
// Independent dense inverse with a posteriori interval residual certificate.
|
|
// Used only for small fixture partitions, never as a production solver.
|
|
double CertifiedInverse(const fesa::SparseMatrix& matrix,
|
|
const std::vector<std::size_t>& free) {
|
|
const auto n = free.size();
|
|
std::vector<std::vector<double>> a(n, std::vector<double>(n)),
|
|
z(n, std::vector<double>(n));
|
|
for (std::size_t i = 0; i < n; ++i) {
|
|
z[i][i] = 1;
|
|
for (std::size_t k = matrix.RowOffsets()[free[i]];
|
|
k < matrix.RowOffsets()[free[i] + 1]; ++k)
|
|
for (std::size_t j = 0; j < n; ++j)
|
|
if (matrix.ColumnIndices()[k] == free[j]) a[i][j] = matrix.Values()[k];
|
|
}
|
|
const auto original = a;
|
|
for (std::size_t k = 0; k < n; ++k) {
|
|
std::size_t pivot = k;
|
|
for (std::size_t i = k + 1; i < n; ++i)
|
|
if (std::abs(a[i][k]) > std::abs(a[pivot][k])) pivot = i;
|
|
if (a[pivot][k] == 0)
|
|
throw std::runtime_error{"Singular independent inverse."};
|
|
std::swap(a[k], a[pivot]);
|
|
std::swap(z[k], z[pivot]);
|
|
const double scale = a[k][k];
|
|
for (std::size_t j = 0; j < n; ++j) {
|
|
a[k][j] /= scale;
|
|
z[k][j] /= scale;
|
|
}
|
|
for (std::size_t i = 0; i < n; ++i)
|
|
if (i != k) {
|
|
const double factor = a[i][k];
|
|
for (std::size_t j = 0; j < n; ++j) {
|
|
a[i][j] -= factor * a[k][j];
|
|
z[i][j] -= factor * z[k][j];
|
|
}
|
|
}
|
|
}
|
|
double theta = 0, znorm = 0;
|
|
for (std::size_t i = 0; i < n; ++i) {
|
|
I defect, row;
|
|
for (std::size_t j = 0; j < n; ++j) {
|
|
I entry{static_cast<double>(i == j)};
|
|
for (std::size_t k = 0; k < n; ++k)
|
|
entry = entry - I{z[i][k]} * I{original[k][j]};
|
|
defect = defect + I{entry.Abs()};
|
|
row = row + I{std::abs(z[i][j])};
|
|
}
|
|
theta = std::max(theta, defect.hi);
|
|
znorm = std::max(znorm, row.hi);
|
|
}
|
|
if (theta >= 1)
|
|
throw std::runtime_error{"Independent inverse certificate inconclusive."};
|
|
return (I{znorm} / (I{1} - I{theta})).hi;
|
|
}
|
|
|
|
TEST(ThermalPhysics,
|
|
PrivateFullEndStripRespectsThicknessMaterialJumpAndFoldResistance) {
|
|
fesa::SerialParallelFor parallel;
|
|
for (bool folded : {false, true}) {
|
|
auto m = Mesh(1, 1, 1, [](auto, auto) { return 0.; });
|
|
m.nodes.push_back(
|
|
{{"plate", 5, "5"}, {folded ? 1. : 2., 0, folded ? 1. : 0.}, {}});
|
|
m.nodes.push_back(
|
|
{{"plate", 6, "6"}, {folded ? 1. : 2., 1, folded ? 1. : 0.}, {}});
|
|
m.thermal_initial_conditions.push_back({4, 0, {}});
|
|
m.thermal_initial_conditions.push_back({5, 0, {}});
|
|
m.thermal_materials.push_back({{"plate", 2, "2"}, "high-k", 10, 1, 1, {}});
|
|
m.thermal_sections.push_back({{"plate", 2, "2"}, "thin", .5, 1, {}});
|
|
m.thermal_elements.push_back({{"plate", 2, "2"}, {{1, 4, 5, 3}}, 1, {}});
|
|
Prepared p{std::move(m), parallel};
|
|
const auto zero = ZeroLike(p.assembly.Capacity());
|
|
ti::ThermalPartition partition;
|
|
std::vector<double> g;
|
|
for (std::size_t node = 0; node < 6; ++node)
|
|
for (std::size_t station = 0; station < 5; ++station) {
|
|
if (node == 1 || node == 3)
|
|
partition.free.push_back(5 * node + station);
|
|
else {
|
|
partition.constrained.push_back(5 * node + station);
|
|
g.push_back(node >= 4 ? 1. : 0.);
|
|
}
|
|
}
|
|
partition.prescribed = Vector{g.size()};
|
|
for (std::size_t i = 0; i < g.size(); ++i) partition.prescribed[i] = g[i];
|
|
ti::ThermalFactorization cache;
|
|
fesa::MklPardisoSolver solver;
|
|
const auto result = Take(ti::SolveThermalIncrement(
|
|
{p.assembly.Conductivity(), zero, p.assembly.HeatInput(),
|
|
&p.assembly.ConductivityError(), &zero, &p.assembly.HeatInputError()},
|
|
partition, Vector{30}, 1, solver, cache));
|
|
const double inverse =
|
|
CertifiedInverse(p.assembly.Conductivity(), partition.free);
|
|
double residual = 0, coefficient_error = 0;
|
|
for (auto i : partition.free) {
|
|
residual = std::max(residual, result.certified_residual[i]);
|
|
I row;
|
|
for (std::size_t k = p.assembly.ConductivityError().RowOffsets()[i];
|
|
k < p.assembly.ConductivityError().RowOffsets()[i + 1]; ++k)
|
|
row = row + I{p.assembly.ConductivityError().Values()[k]};
|
|
coefficient_error = std::max(coefficient_error, row.hi);
|
|
}
|
|
const I denominator = I{1} - I{inverse} * I{coefficient_error};
|
|
ASSERT_GT(denominator.lo, 0);
|
|
const I bound = I{inverse} / denominator * I{residual};
|
|
const I mid = I{5} / I{6}; // R=1/(1*1*1)+1/(10*.5*1)=6/5.
|
|
for (auto i : partition.free)
|
|
EXPECT_LE((I{result.temperature[i]} - mid).Abs(),
|
|
bound.hi + (mid - I{mid.Mid()}).Abs());
|
|
I left, right;
|
|
for (std::size_t i = 0; i < partition.constrained.size(); ++i)
|
|
if (partition.constrained[i] / 5 >= 4)
|
|
right = right + I{result.reaction[i]};
|
|
else
|
|
left = left + I{result.reaction[i]};
|
|
I reaction_budget;
|
|
for (auto i : partition.constrained) {
|
|
I row, scale, error;
|
|
for (std::size_t k = p.assembly.Conductivity().RowOffsets()[i];
|
|
k < p.assembly.Conductivity().RowOffsets()[i + 1]; ++k) {
|
|
const auto j = p.assembly.Conductivity().ColumnIndices()[k];
|
|
row = row + I{std::abs(p.assembly.Conductivity().Values()[k])} * bound;
|
|
scale = scale + I{std::abs(p.assembly.Conductivity().Values()[k])} *
|
|
I{std::abs(result.temperature[j])};
|
|
error = error + I{p.assembly.ConductivityError().Values()[k]} *
|
|
I{std::abs(result.temperature[j])};
|
|
}
|
|
const auto terms = p.assembly.Conductivity().RowOffsets()[i + 1] -
|
|
p.assembly.Conductivity().RowOffsets()[i];
|
|
reaction_budget =
|
|
reaction_budget + row + error + Gamma(2 * terms + 2) * scale;
|
|
}
|
|
EXPECT_LE((right - mid).Abs(), reaction_budget.hi);
|
|
EXPECT_LE((left + mid).Abs(), reaction_budget.hi);
|
|
EXPECT_LE((left + right).Abs(), result.evidence.energy_bound);
|
|
auto flux = Take(p.assembly.RecoverFlux(result.temperature, parallel));
|
|
for (const auto& q : flux[0])
|
|
EXPECT_LE((I{q.X()} + mid).Abs(), 24 * bound.hi + Gamma(2048).hi * 24);
|
|
for (const auto& q : flux[1]) {
|
|
const double component = folded ? q.Z() : q.X();
|
|
EXPECT_LE((I{component} + I{5} / I{3}).Abs(),
|
|
400 * bound.hi + Gamma(2048).hi * 400);
|
|
}
|
|
std::cout << std::setprecision(17) << "THERMAL_STRIP folded=" << folded
|
|
<< " resistance=1.2 reaction=" << right.Mid()
|
|
<< " forward_bound=" << bound.hi
|
|
<< " beta=" << result.evidence.beta_cert << '\n';
|
|
}
|
|
}
|
|
|
|
TEST(ThermalPhysics,
|
|
PrivateAffineFieldRotationNormalAndUnaveragedMidplaneTraces) {
|
|
fesa::SerialParallelFor parallel;
|
|
const auto rotate = [](Vector3 v) { return Vector3{v.Z(), v.X(), v.Y()}; };
|
|
for (double h : {.5, 1., 2.})
|
|
for (double k : {1., 10.})
|
|
for (bool flip : {false, true})
|
|
for (bool rotated : {false, true}) {
|
|
SCOPED_TRACE(h);
|
|
SCOPED_TRACE(k);
|
|
SCOPED_TRACE(flip);
|
|
SCOPED_TRACE(rotated);
|
|
auto m = Mesh(1, 1, 1, [](auto, auto) { return 0.; });
|
|
m.thermal_sections[0].thickness = h;
|
|
m.thermal_materials[0].conductivity = k;
|
|
if (flip) m.thermal_elements[0].node_indices = {{0, 2, 3, 1}};
|
|
Vector values{20};
|
|
for (std::size_t node = 0; node < 4; ++node) {
|
|
const auto& r = m.nodes[node].coordinates;
|
|
for (std::size_t station = 0; station < 5; ++station) {
|
|
const double zeta = -1 + .5 * station;
|
|
values[5 * node + station] =
|
|
2 + 3 * r[0] - 2 * r[1] + 4 * (flip ? -1 : 1) * h * zeta / 2;
|
|
}
|
|
if (rotated) {
|
|
const auto r_new = rotate(Vector3{r[0], r[1], r[2]});
|
|
m.nodes[node].coordinates = {{r_new.X(), r_new.Y(), r_new.Z()}};
|
|
}
|
|
}
|
|
Prepared p{std::move(m), parallel};
|
|
ti::ThermalPartition partition;
|
|
for (std::size_t i = 0; i < 20; ++i)
|
|
partition.constrained.push_back(i);
|
|
partition.prescribed = values;
|
|
fesa::MklPardisoSolver solver;
|
|
ti::ThermalFactorization cache;
|
|
const auto result = Take(ti::SolveThermalIncrement(
|
|
{p.assembly.Conductivity(), p.assembly.Capacity(),
|
|
p.assembly.HeatInput()},
|
|
partition, values, 1, solver, cache));
|
|
EXPECT_FALSE(cache.matrix.has_value());
|
|
const auto flux =
|
|
Take(p.assembly.RecoverFlux(result.temperature, parallel));
|
|
Vector3 expected{-3 * k, 2 * k, -4 * k};
|
|
if (rotated) expected = rotate(expected);
|
|
double scale = 0;
|
|
for (std::size_t i = 0; i < 20; ++i)
|
|
scale = std::max(scale, std::abs(values[i]));
|
|
const double budget = (Gamma(2048) * I{k * (8 + 16 / h) * scale}).hi;
|
|
for (std::size_t point = 0; point < 4; ++point) {
|
|
const auto& r = p.state.FluxLocalFrames()[0][point];
|
|
for (std::size_t a = 0; a < 3; ++a)
|
|
for (std::size_t b = 0; b < 3; ++b) {
|
|
I dot, absolute;
|
|
for (std::size_t c = 0; c < 3; ++c) {
|
|
dot = dot + I{r[a][c]} * I{r[b][c]};
|
|
absolute = absolute + I{std::abs(r[a][c] * r[b][c])};
|
|
}
|
|
EXPECT_LE((dot - I{static_cast<double>(a == b)}).Abs(),
|
|
(Gamma(2048) * absolute).hi);
|
|
}
|
|
EXPECT_GT(r[0].Cross(r[1]).Dot(r[2]), 0);
|
|
for (std::size_t trace = 0; trace < 6; ++trace) {
|
|
const auto& q = flux[0][6 * point + trace];
|
|
for (std::size_t c = 0; c < 3; ++c)
|
|
EXPECT_LE(std::abs(q[c] - expected[c]), budget);
|
|
for (std::size_t axis = 0; axis < 3; ++axis) {
|
|
I actual_local, expected_local;
|
|
for (std::size_t c = 0; c < 3; ++c) {
|
|
actual_local = actual_local + I{r[axis][c]} * I{q[c]};
|
|
expected_local =
|
|
expected_local + I{r[axis][c]} * I{expected[c]};
|
|
}
|
|
EXPECT_LE((actual_local - expected_local).Abs(),
|
|
budget + Gamma(16).hi * k * (8 + 16 / h) * scale);
|
|
}
|
|
}
|
|
}
|
|
// The discontinuous derivative at the shared station has two distinct
|
|
// one-sided traces; prescribed interior stations exist only in this
|
|
// private algebra fixture, never in the public Domain BC definition.
|
|
for (std::size_t node = 0; node < 4; ++node) {
|
|
for (std::size_t station = 0; station < 5; ++station)
|
|
values[5 * node + station] =
|
|
station < 3 ? 0. : static_cast<double>(station - 2);
|
|
}
|
|
partition.prescribed = values;
|
|
const auto trace_result = Take(ti::SolveThermalIncrement(
|
|
{p.assembly.Conductivity(), p.assembly.Capacity(),
|
|
p.assembly.HeatInput()},
|
|
partition, values, 1, solver, cache));
|
|
const auto traces =
|
|
Take(p.assembly.RecoverFlux(trace_result.temperature, parallel));
|
|
for (std::size_t point = 0; point < 4; ++point) {
|
|
const auto& normal = p.state.FluxLocalFrames()[0][point][2];
|
|
EXPECT_EQ(traces[0][6 * point + 2].Dot(normal), 0);
|
|
EXPECT_LE(
|
|
std::abs(traces[0][6 * point + 3].Dot(normal) + 4 * k / h),
|
|
(Gamma(2048) * I{2 * k * (8 + 16 / h)}).hi);
|
|
}
|
|
}
|
|
}
|
|
|
|
I ThicknessMass(const std::array<I, 5>& v) {
|
|
I result;
|
|
for (std::size_t segment = 0; segment < 2; ++segment) {
|
|
const I m = (v[2 * segment] + v[2 * segment + 2]) / I{2};
|
|
const I d = (v[2 * segment + 2] - v[2 * segment]) / I{2};
|
|
const I middle = v[2 * segment + 1];
|
|
// Positive square decomposition of the exact two-P2 consistent mass.
|
|
result = result + (I{6} * Square(m + I{2} / I{3} * middle) +
|
|
I{40} / I{3} * Square(middle) + I{10} * Square(d)) /
|
|
I{60};
|
|
}
|
|
return result;
|
|
}
|
|
I ThicknessGradient(const std::array<I, 5>& v) {
|
|
I result;
|
|
for (std::size_t segment = 0; segment < 2; ++segment) {
|
|
const I left = v[2 * segment] - v[2 * segment + 1],
|
|
right = v[2 * segment + 2] - v[2 * segment + 1];
|
|
result = result +
|
|
I{2} / I{3} *
|
|
(I{6} * (Square(left) + Square(right)) + Square(left + right));
|
|
}
|
|
return result;
|
|
}
|
|
struct SpatialError {
|
|
I temperature, gradient;
|
|
};
|
|
template <std::size_t Order>
|
|
SpatialError IntegrateSpatialError(
|
|
const Vector& values, std::size_t n,
|
|
const std::array<thermal_oracle::GaussPoint, Order>& rule, I amplitude) {
|
|
I temperature, gradient;
|
|
for (std::size_t y = 0; y < n; ++y)
|
|
for (std::size_t x = 0; x < n; ++x) {
|
|
const std::size_t node = y * (n + 1) + x;
|
|
const std::array<std::size_t, 4> nodes{node, node + 1, node + n + 2,
|
|
node + n + 1};
|
|
for (const auto& gx : rule) {
|
|
const I u = (I{1} + I{gx.x_lo, gx.x_hi}) / I{2};
|
|
const I position =
|
|
(I{static_cast<double>(x)} + u) / I{static_cast<double>(n)};
|
|
const I phase = Pi() * position;
|
|
const I exact = Cos(phase) * amplitude;
|
|
const I exact_gradient =
|
|
I{-1} * Pi() * Cos(Pi() / I{2} - phase) * amplitude;
|
|
for (const auto& gy : rule) {
|
|
const I v = (I{1} + I{gy.x_lo, gy.x_hi}) / I{2};
|
|
const I weight =
|
|
I{gx.w_lo, gx.w_hi} * I{gy.w_lo, gy.w_hi} / I{4. * n * n};
|
|
std::array<I, 5> field, dx, dy, error;
|
|
for (std::size_t a = 0; a < 5; ++a) {
|
|
const I a0{values[5 * nodes[0] + a]}, a1{values[5 * nodes[1] + a]},
|
|
a2{values[5 * nodes[2] + a]}, a3{values[5 * nodes[3] + a]};
|
|
field[a] = (I{1} - v) * ((I{1} - u) * a0 + u * a1) +
|
|
v * ((I{1} - u) * a3 + u * a2);
|
|
error[a] = field[a] - exact;
|
|
dx[a] = I{static_cast<double>(n)} *
|
|
((I{1} - v) * (a1 - a0) + v * (a2 - a3)) -
|
|
exact_gradient;
|
|
dy[a] = I{static_cast<double>(n)} *
|
|
((I{1} - u) * (a3 - a0) + u * (a2 - a1));
|
|
}
|
|
temperature = temperature + weight * ThicknessMass(error);
|
|
gradient =
|
|
gradient + weight * (ThicknessMass(dx) + ThicknessMass(dy) +
|
|
ThicknessGradient(field));
|
|
}
|
|
}
|
|
}
|
|
return {Sqrt(temperature), Sqrt(gradient)};
|
|
}
|
|
TEST(ThermalPhysics,
|
|
FullTwoDimensionalMeshesHaveSecondOrderTemperatureAndFirstOrderGradient) {
|
|
fesa::SerialParallelFor parallel;
|
|
constexpr double period = .001;
|
|
constexpr std::uint32_t count = 32;
|
|
const I continuum_amplitude = ExpNegative(Pi() * Pi() * I{period});
|
|
double previous_temperature = 0, previous_gradient = 0;
|
|
for (std::size_t n : {8U, 16U, 32U, 64U}) {
|
|
SCOPED_TRACE(n);
|
|
std::vector<I> mode(n + 1);
|
|
double initial_error = 0;
|
|
for (std::size_t i = 0; i <= n; ++i) {
|
|
mode[i] =
|
|
Cos(Pi() * I{static_cast<double>(i)} / I{static_cast<double>(n)});
|
|
initial_error =
|
|
std::max(initial_error, (mode[i] - I{mode[i].Mid()}).Abs());
|
|
}
|
|
Prepared p{Mesh(n, period, count,
|
|
[&](std::size_t i, auto) { return mode[i].Mid(); }),
|
|
parallel};
|
|
const auto metrics =
|
|
Advance(p, parallel, Down(1. / (2160 * n * n)), initial_error);
|
|
const auto& actual = p.state.CommittedState().temperature;
|
|
const auto twelve = IntegrateSpatialError(
|
|
actual, n, thermal_oracle::kGauss12, continuum_amplitude);
|
|
const auto sixteen = IntegrateSpatialError(
|
|
actual, n, thermal_oracle::kGauss16, continuum_amplitude);
|
|
EXPECT_LE((twelve.temperature - sixteen.temperature).Abs(),
|
|
sixteen.temperature.lo * 1e-8);
|
|
EXPECT_LE((twelve.gradient - sixteen.gradient).Abs(),
|
|
sixteen.gradient.lo * 1e-8);
|
|
const I lambda = I{6. * n * n} * (I{1} - mode[1]) / (I{2} + mode[1]);
|
|
const I semidiscrete = ExpNegative(lambda * I{period});
|
|
const I be = Power(I{1} / (I{1} + lambda * I{period / count}), count);
|
|
Vector spatial{actual.Size()}, difference{actual.Size()},
|
|
mode_values{actual.Size()};
|
|
double oracle_width = 0;
|
|
for (std::size_t node = 0; node < (n + 1) * (n + 1); ++node)
|
|
for (std::size_t a = 0; a < 5; ++a) {
|
|
const auto i = node % (n + 1);
|
|
const I expected = mode[i] * be;
|
|
spatial[5 * node + a] = (mode[i] * semidiscrete).Mid();
|
|
mode_values[5 * node + a] = mode[i].Mid();
|
|
difference[5 * node + a] = actual[5 * node + a] - expected.Mid();
|
|
oracle_width =
|
|
std::max(oracle_width, (expected - I{expected.Mid()}).Abs());
|
|
}
|
|
const I agreement = CapacityNorm(difference, n);
|
|
const I forward = I{metrics.capacity_budget} + I{oracle_width};
|
|
EXPECT_LE(agreement.hi, forward.hi);
|
|
EXPECT_LE(forward.hi, sixteen.temperature.lo / 1000);
|
|
EXPECT_LE((Sqrt(I{24. * n * n + 1280}) * forward).hi,
|
|
sixteen.gradient.lo / 1000);
|
|
const auto spatial_error = IntegrateSpatialError(
|
|
spatial, n, thermal_oracle::kGauss12, continuum_amplitude);
|
|
const I temporal =
|
|
I{(be - semidiscrete).Abs()} * CapacityNorm(mode_values, n);
|
|
EXPECT_LE(temporal.hi, spatial_error.temperature.lo / 32);
|
|
double temperature_order = 0, gradient_order = 0;
|
|
if (previous_temperature > 0) {
|
|
temperature_order =
|
|
std::log2(previous_temperature / sixteen.temperature.Mid());
|
|
gradient_order = std::log2(previous_gradient / sixteen.gradient.Mid());
|
|
EXPECT_GE(temperature_order, 1.95);
|
|
EXPECT_LE(temperature_order, 2.05);
|
|
EXPECT_GE(gradient_order, .98);
|
|
EXPECT_LE(gradient_order, 1.03);
|
|
}
|
|
previous_temperature = sixteen.temperature.Mid();
|
|
previous_gradient = sixteen.gradient.Mid();
|
|
Print("space", n, count, metrics);
|
|
std::cout << std::setprecision(17) << "THERMAL_SPACE n=" << n
|
|
<< " T_error=" << sixteen.temperature.Mid()
|
|
<< " gradient_error=" << sixteen.gradient.Mid()
|
|
<< " T_order=" << temperature_order
|
|
<< " gradient_order=" << gradient_order << " time_spatial_ratio="
|
|
<< (temporal / spatial_error.temperature).hi
|
|
<< " quadrature_T_gap="
|
|
<< (twelve.temperature - sixteen.temperature).Abs()
|
|
<< " quadrature_gradient_gap="
|
|
<< (twelve.gradient - sixteen.gradient).Abs()
|
|
<< " modal_agreement=" << agreement.hi
|
|
<< " roundoff_budget=" << forward.hi << '\n';
|
|
if (n == 64)
|
|
EXPECT_EQ(8 * (metrics.temperature_values + metrics.flux_values),
|
|
81074472U);
|
|
}
|
|
}
|
|
I Bracket(thermal_oracle::Bracket x) { return {x.lo, x.hi}; }
|
|
class ThermalSlab
|
|
: public testing::TestWithParam<std::pair<int, std::uint32_t>> {};
|
|
TEST_P(ThermalSlab, ActualMeshesMatchCertifiedP2AndSeparateFourierError) {
|
|
const auto [case_index, count] = GetParam();
|
|
const auto& oracle = thermal_oracle::kSlab[case_index];
|
|
const auto& be = count == 4096 ? oracle.be4096 : oracle.be8192;
|
|
fesa::SerialParallelFor parallel;
|
|
std::array<I, 13> first_mesh;
|
|
std::array<double, 4> first_budget{};
|
|
for (std::size_t n : {1U, 2U}) {
|
|
auto definition =
|
|
Mesh(n, oracle.time, count, [](auto, auto) { return 0.; });
|
|
for (std::size_t node = 0; node < definition.nodes.size(); ++node)
|
|
definition.thermal_model_boundaries.push_back(
|
|
{static_cast<fesa::EntityIndex>(node), 11, 1, {}});
|
|
Prepared p{std::move(definition), parallel};
|
|
const double mass_lower = Down(1. / (2160 * n * n));
|
|
for (std::size_t row = 0; row < p.state.CommittedState().temperature.Size();
|
|
++row)
|
|
EXPECT_EQ(p.state.CommittedState().temperature[row], 0);
|
|
const auto metrics = Advance(p, parallel, mass_lower);
|
|
const auto& final = p.state.CommittedState();
|
|
// Independently certify the small last-step inverse as well as the
|
|
// structured C-norm propagation used for the full 4096/8192-step history.
|
|
const auto& c = p.assembly.Capacity();
|
|
const auto& k = p.assembly.Conductivity();
|
|
const double delta = final.time_increment;
|
|
std::vector<fesa::CooContribution> coo;
|
|
double operator_error = 0;
|
|
for (std::size_t row = 0; row < c.Rows(); ++row) {
|
|
I error;
|
|
for (auto entry = c.RowOffsets()[row]; entry < c.RowOffsets()[row + 1];
|
|
++entry) {
|
|
const double center = c.Values()[entry] / delta + k.Values()[entry];
|
|
coo.push_back({row, c.ColumnIndices()[entry], center, 0, entry});
|
|
const I exact = (I{c.Values()[entry]} +
|
|
I{-p.assembly.CapacityError().Values()[entry],
|
|
p.assembly.CapacityError().Values()[entry]}) /
|
|
I{delta} +
|
|
I{k.Values()[entry]} +
|
|
I{-p.assembly.ConductivityError().Values()[entry],
|
|
p.assembly.ConductivityError().Values()[entry]};
|
|
error = error + I{(exact - I{center}).Abs()};
|
|
}
|
|
operator_error = std::max(operator_error, error.hi);
|
|
}
|
|
const auto a =
|
|
Take(fesa::SparseMatrix::FromCoo(c.Rows(), c.Columns(), std::move(coo),
|
|
{c.RowOffsets(), c.ColumnIndices()}));
|
|
const double inverse = CertifiedInverse(a, p.dofs.FreeDofs());
|
|
const I inverse_denominator = I{1} - I{inverse} * I{operator_error};
|
|
ASSERT_GT(inverse_denominator.lo, 0);
|
|
const I local_forward =
|
|
I{inverse} / inverse_denominator * I{metrics.last_free_residual_inf};
|
|
const I temperature_budget =
|
|
I{metrics.capacity_budget} / Sqrt(I{mass_lower});
|
|
double temperature_scale = 0;
|
|
for (std::size_t row = 0; row < final.temperature.Size(); ++row)
|
|
temperature_scale =
|
|
std::max(temperature_scale, std::abs(final.temperature[row]));
|
|
const I flux_budget = I{8. * n + 16} * (temperature_budget +
|
|
Gamma(2048) * I{temperature_scale});
|
|
I energy, reaction;
|
|
constexpr int thickness_weight[5] = {1, 4, 2, 4, 1};
|
|
for (std::size_t j = 0; j <= n; ++j)
|
|
for (std::size_t i = 0; i <= n; ++i) {
|
|
const int plane_weight =
|
|
(i == 0 || i == n ? 1 : 2) * (j == 0 || j == n ? 1 : 2);
|
|
for (std::size_t a = 0; a < 5; ++a)
|
|
energy =
|
|
energy +
|
|
I{final.temperature[5 * (j * (n + 1) + i) + a]} *
|
|
I{static_cast<double>(plane_weight * thickness_weight[a])} /
|
|
I{48. * n * n};
|
|
}
|
|
for (std::size_t row = 0; row < final.completed->reaction_heat_rate.Size();
|
|
++row)
|
|
reaction = reaction + I{final.completed->reaction_heat_rate[row]};
|
|
// Exact P2 Schur reaction row L = (-400/51,56/17,-80/51,28/51),
|
|
// L Cff^-1 L^T = 6447104/14739. Plane integration is a contraction
|
|
// in the product C norm; Ccf Cff^-1 has infinity norm 3/17.
|
|
const I reaction_budget =
|
|
Sqrt(I{6447104} / I{14739}) * I{metrics.capacity_budget} +
|
|
(I{3} / I{17}) * I{metrics.last_free_residual_l1} +
|
|
I{metrics.last_reaction_evaluation_error} +
|
|
I{(reaction - I{reaction.Mid()}).Abs()};
|
|
const std::array<double, 4> solver_budget{
|
|
temperature_budget.hi, flux_budget.hi,
|
|
(I{metrics.capacity_budget} + I{(energy - I{energy.Mid()}).Abs()}).hi,
|
|
reaction_budget.hi};
|
|
std::array<double, 4> agreement{}, physical{}, oracle_budget{},
|
|
time_error{}, space_error{};
|
|
const auto observe = [&](std::size_t quantity, std::size_t group, I value) {
|
|
agreement[group] =
|
|
std::max(agreement[group], (value - Bracket(be[quantity])).Abs());
|
|
physical[group] = std::max(
|
|
physical[group], (value - Bracket(oracle.fourier[quantity])).Abs());
|
|
};
|
|
for (std::size_t quantity = 0; quantity < 13; ++quantity) {
|
|
const std::size_t group = quantity < 5 ? 0
|
|
: quantity < 11 ? 1
|
|
: quantity - 9;
|
|
oracle_budget[group] = std::max(
|
|
oracle_budget[group],
|
|
(I{be[quantity].hi} - I{be[quantity].lo} +
|
|
I{oracle.continuous[quantity].hi} -
|
|
I{oracle.continuous[quantity].lo} + I{oracle.fourier[quantity].hi} -
|
|
I{oracle.fourier[quantity].lo})
|
|
.hi);
|
|
time_error[group] = std::max(
|
|
time_error[group],
|
|
(Bracket(be[quantity]) - Bracket(oracle.continuous[quantity])).Abs());
|
|
space_error[group] =
|
|
std::max(space_error[group], (Bracket(oracle.continuous[quantity]) -
|
|
Bracket(oracle.fourier[quantity]))
|
|
.Abs());
|
|
}
|
|
for (std::size_t row = 0; row < final.temperature.Size(); ++row)
|
|
observe(row % 5, 0, I{final.temperature[row]});
|
|
for (const auto& element : final.completed->global_heat_flux)
|
|
for (std::size_t sample = 0; sample < 24; ++sample) {
|
|
EXPECT_LE(std::abs(element[sample][0]), flux_budget.hi);
|
|
EXPECT_LE(std::abs(element[sample][1]), flux_budget.hi);
|
|
observe(5 + sample % 6, 1, I{element[sample][2]});
|
|
}
|
|
observe(11, 2, energy);
|
|
observe(12, 3, reaction);
|
|
std::array<I, 13> samples;
|
|
for (std::size_t a = 0; a < 5; ++a) samples[a] = I{final.temperature[a]};
|
|
for (std::size_t trace = 0; trace < 6; ++trace)
|
|
samples[5 + trace] = I{final.completed->global_heat_flux[0][trace][2]};
|
|
samples[11] = energy;
|
|
samples[12] = reaction;
|
|
if (n == 1) {
|
|
first_mesh = samples;
|
|
first_budget = solver_budget;
|
|
} else {
|
|
for (std::size_t quantity = 0; quantity < 13; ++quantity) {
|
|
const std::size_t group = quantity < 5 ? 0
|
|
: quantity < 11 ? 1
|
|
: quantity - 9;
|
|
EXPECT_LE((samples[quantity] - first_mesh[quantity]).Abs(),
|
|
(I{first_budget[group]} + I{solver_budget[group]}).hi);
|
|
}
|
|
}
|
|
Print("slab", n, count, metrics);
|
|
for (std::size_t group = 0; group < 4; ++group) {
|
|
const I roundoff = I{solver_budget[group]} + I{oracle_budget[group]};
|
|
EXPECT_LE(roundoff.hi, oracle.space[group] / 1000);
|
|
EXPECT_LE(agreement[group], roundoff.hi);
|
|
EXPECT_LE(physical[group],
|
|
(I{oracle.space[group]} + I{time_error[group]} + roundoff).hi);
|
|
EXPECT_LE((I{physical[group]} - I{space_error[group]}).Abs(),
|
|
(I{time_error[group]} + roundoff).hi);
|
|
const bool plateau =
|
|
(I{time_error[group]} + roundoff).hi <= space_error[group] / 10;
|
|
if (case_index < 4 && count == 8192) EXPECT_TRUE(plateau);
|
|
std::cout << std::setprecision(17) << "THERMAL_SLAB time=" << oracle.time
|
|
<< " n=" << n << " N=" << count << " quantity=" << group
|
|
<< " finite_BE_gap=" << agreement[group]
|
|
<< " solver_bound=" << solver_budget[group]
|
|
<< " oracle_bound=" << oracle_budget[group]
|
|
<< " physical_error=" << physical[group]
|
|
<< " space_error=" << space_error[group]
|
|
<< " D_space=" << oracle.space[group]
|
|
<< " D_time=" << time_error[group] << " plateau=" << plateau
|
|
<< " last_step_inverse_bound=" << inverse
|
|
<< " last_step_forward_bound=" << local_forward.hi
|
|
<< " penetration=" << std::sqrt(oracle.time)
|
|
<< " station_spacing=0.25 segment_length=0.5" << '\n';
|
|
}
|
|
}
|
|
}
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
FixedStations, ThermalSlab,
|
|
testing::Values(std::make_pair(0, 4096U), std::make_pair(0, 8192U),
|
|
std::make_pair(1, 4096U), std::make_pair(1, 8192U),
|
|
std::make_pair(2, 4096U), std::make_pair(2, 8192U),
|
|
std::make_pair(3, 4096U), std::make_pair(3, 8192U),
|
|
std::make_pair(4, 4096U), std::make_pair(4, 8192U),
|
|
std::make_pair(5, 4096U), std::make_pair(5, 8192U)));
|
|
} // namespace
|