baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement private HHT field convergence policy and oracle tests

Browse Source
This commit is contained in:
KOKO\Mimi
2026-10-19 02:20:58 +09:00
parent adb809bc01
commit ad06d7ad6c
7 changed files with 454 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/CMakeLists.txt
+1
View File
@@ -15,6 +15,7 @@ add_executable(
unit/analysis/hht_temporal_verification_test.cpp
unit/analysis/hht_dynamic_algebra_test.cpp
unit/analysis/hht_development_probe_test.cpp
unit/analysis/hht_field_convergence_test.cpp
unit/analysis/hht_reduced_shell_test.cpp
unit/analysis/hht_dynamic_procedure_test.cpp
unit/analysis/nonlinear_analysis_state_test.cpp
tests/unit/analysis/hht_field_convergence_test.cpp
+232
View File
@@ -0,0 +1,232 @@
#include "analysis/hht_field_convergence.h"
#include <gtest/gtest.h>
#include <cmath>
#include <limits>
namespace fesa::hht_field_convergence {
namespace {
using Inputs = std::array<FieldInput, 2>;
using Histories = std::array<History, 2>;
Inputs Normal() {
Inputs f{}; f[0].active = true; f[0].flux = {{2.0, 0.0}};
f[0].residual = .01; f[0].increment = 1; f[0].correction = .01;
return f;
}
TEST(HhtFieldConvergence, SignedElementTotalAndSourcePopulationOracle) {
auto f = Normal(); f[0].flux.assign(30, {});
f[0].flux[0] = {8, -6}; f[0].flux[1] = {-2, 0};
f[0].flux[24] = {3, 0}; f[0].flux[27] = {-3, 0};
Histories h{}; h[0].maximum_sum = 10; h[0].maximum_count = 1;
auto r = Evaluate(f, h, 1, 2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux, 2.5);
r = Evaluate(f, {}, 1, 2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux, 1.0/3.0);
}
TEST(HhtFieldConvergence, NormalBoundaryAndInitialCorrectionMissing) {
auto f = Normal(); auto r = Evaluate(f, {}, 1, 2);
ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
f[0].residual = std::nextafter(.005 * 2, INFINITY);
r = Evaluate(f, {}, 1, 2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
f = Normal(); r = Evaluate(f, {}, 0, 2);
ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
EXPECT_FALSE(r.fields[0].correction_pass.has_value());
}
TEST(HhtFieldConvergence, ScalarPopulationThresholdAndReactivation) {
auto f=Normal(); Histories h{}; h[0].maximum_sum=100; h[0].maximum_count=1;
f[0].flux={{0,0},{.001,0},{10,0}};
auto r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux,5.0005);
f[0].flux[2].internal=std::nextafter(10.,0.);
r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux,(.001+std::nextafter(10.,0.))/3);
f[0].flux={{0,0},{0,0}}; r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux,0);
}
TEST(HhtFieldConvergence, InitialAverageAndNonzeroEligibilityBoundary) {
auto f=Normal(); const double edge=1e-5*.01;
for (double x:{std::nextafter(edge,0.),edge,std::nextafter(edge,INFINITY)}) {
f[0].flux={{x,0}}; auto r=Evaluate(f,{},0,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].time_average_flux,x>edge?x:.01);
EXPECT_EQ(r.pending[0].nonzero_count,x>edge?1U:0U);
EXPECT_EQ(r.pending[0].maximum_count,1U);
}
}
TEST(HhtFieldConvergence, PendingHistoryIsRecomputedAndRollbackIsPure) {
auto f=Normal(); Histories h{}; h[0]={10,1,4,1};
f[0].flux={{30,0}}; auto a=Evaluate(f,h,1,2); ASSERT_TRUE(a.status.IsOk());
EXPECT_DOUBLE_EQ(*a.fields[0].time_average_flux,20);
f[0].flux={{70,0}}; auto b=Evaluate(f,h,2,2); ASSERT_TRUE(b.status.IsOk());
EXPECT_DOUBLE_EQ(*b.fields[0].time_average_flux,40);
EXPECT_DOUBLE_EQ(b.pending[0].nonzero_sum,80);
EXPECT_DOUBLE_EQ(b.pending[0].maximum_sum,74);
EXPECT_EQ(b.pending[0].maximum_count,2U);
EXPECT_DOUBLE_EQ(h[0].nonzero_sum,10); EXPECT_EQ(h[0].nonzero_count,1U);
f[0].flux={{0,0}}; auto z=Evaluate(f,h,1,2); ASSERT_TRUE(z.status.IsOk());
EXPECT_EQ(z.pending[0].nonzero_count,1U); EXPECT_EQ(z.pending[0].maximum_count,2U);
EXPECT_DOUBLE_EQ(z.pending[0].maximum_sum,4);
}
TEST(HhtFieldConvergence, RawScaleConversionIsSimultaneousAndUnitConsistent) {
auto f=Normal(); Histories h{}; h[0]={3,1,3,1}; h[1]={.3,1,.3,1};
f[0].flux={{3,0}}; f[1].active=true; f[1].flux={{.1,0}};
auto r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].residual_scale,3);
EXPECT_DOUBLE_EQ(*r.fields[1].time_average_flux,.2);
EXPECT_DOUBLE_EQ(*r.fields[1].residual_scale,6);
f[1].active=false; r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[1].branch,Branch::kNotEvaluated);
EXPECT_FALSE(r.fields[1].field_pass.has_value());
}
TEST(HhtFieldConvergence, EstimatedCorrectionHasRealHistoryAndNormalOnly) {
auto f=Normal(); f[0].flux={{400,0}}; f[0].residual=2;
f[0].correction=.04; f[0].previous_residual=4; f[0].older_residual=8;
auto r=Evaluate(f,{},2,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].estimated_correction,.02); EXPECT_FALSE(r.field_pass);
f[0].residual=1; r=Evaluate(f,{},2,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].estimated_correction,.01); EXPECT_TRUE(r.field_pass);
f[0].older_residual=0; r=Evaluate(f,{},2,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_FALSE(r.fields[0].estimated_correction.has_value()); EXPECT_FALSE(r.field_pass);
f[0].older_residual=8; r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_FALSE(r.fields[0].estimated_correction.has_value()); EXPECT_FALSE(r.field_pass);
}
TEST(HhtFieldConvergence, NonquadraticIterationAndRateBoundaries) {
auto f=Normal(); f[0].flux={{100,0}}; f[0].residual=2;
f[0].previous_residual=4; f[0].older_residual=8;
auto r=Evaluate(f,{},9,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,Branch::kNormal); EXPECT_FALSE(r.field_pass);
r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,Branch::kNonquadratic); EXPECT_TRUE(r.field_pass);
EXPECT_FALSE(r.fields[0].estimated_correction.has_value());
f[0].older_residual=16; f[0].residual=1;
r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_EQ(r.fields[0].branch,Branch::kNonquadratic);
f[0].residual=.5; r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,Branch::kNormal);
f[0].residual=4; r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,Branch::kNormal);
}
TEST(HhtFieldConvergence, ZeroFluxUsesResidualOrActualCorrectionAtBoundary) {
auto f=Normal(); Histories h{}; h[0]={2,1,2,1};
f[0].flux={{0,0}}; f[0].residual=1e-5*2; f[0].correction.reset();
auto r=Evaluate(f,h,0,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
EXPECT_EQ(r.fields[0].branch,Branch::kZeroFlux); EXPECT_FALSE(r.fields[0].correction_pass.has_value());
f[0].residual=std::nextafter(1e-5*2,INFINITY);
r=Evaluate(f,h,0,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
f[0].correction=.001; r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
f[0].correction=std::nextafter(.001,INFINITY);
r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
f[0].increment=0; f[0].correction=0;
r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
}
TEST(HhtFieldConvergence, LinearRequiresEveryActiveFieldAndAnActualIteration) {
auto f=Normal(); f[1]=f[0]; f[1].flux={{4,0}};
f[0].residual=2e-8; f[1].residual=4e-8; f[0].correction.reset(); f[1].correction.reset();
auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
EXPECT_EQ(r.fields[0].branch,Branch::kLinear); EXPECT_EQ(r.fields[1].branch,Branch::kLinear);
f[1].residual=std::nextafter(4e-8,INFINITY);
r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
EXPECT_EQ(r.fields[0].branch,Branch::kNormal);
f[1].residual=4e-8; r=Evaluate(f,{},0,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
}
TEST(HhtFieldConvergence, SmallTranslationExemptionIsStrictAndNeverRotational) {
auto f=Normal(); f[0].increment=std::nextafter(2e-8,0.); f[0].correction=1;
auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
EXPECT_FALSE(r.fields[0].correction_pass.has_value());
f[0].increment=2e-8; r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
f[1]=f[0]; f[0].active=false; f[1].increment=0; f[1].correction=0;
r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_TRUE(r.field_pass);
f[1].correction=std::numeric_limits<double>::denorm_min();
r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk()); EXPECT_FALSE(r.field_pass);
}
TEST(HhtFieldConvergence, InvalidAndOverflowNeverBecomeMissingOrPassing) {
const double inf=std::numeric_limits<double>::infinity();
const double nan=std::numeric_limits<double>::quiet_NaN();
const double max=std::numeric_limits<double>::max();
for(double x:{0.,-1.,inf,nan}) EXPECT_FALSE(Evaluate(Normal(),{},1,x).status.IsOk());
for(double x:{-1.,inf,nan}) {
auto f=Normal(); f[0].residual=x; EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
f=Normal(); f[0].correction=x; EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
f=Normal(); f[0].older_residual=x; EXPECT_FALSE(Evaluate(f,{},2,2).status.IsOk());
f=Normal(); f[0].flux={{x,0}};
if(x!=-1.) EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
}
auto f=Normal(); f[0].flux.clear(); EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
f=Normal(); f[0].flux={{max,max}}; EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
f=Normal(); f[0].flux={{max,0},{max,0}}; EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
f=Normal(); f[0].older_residual=std::numeric_limits<double>::denorm_min();
f[0].previous_residual=1; EXPECT_FALSE(Evaluate(f,{},2,2).status.IsOk());
Histories h{}; h[0]={max,1,max,1}; f=Normal(); f[0].flux={{max,0}}; EXPECT_FALSE(Evaluate(f,h,1,2).status.IsOk());
h={}; h[0].maximum_count=std::numeric_limits<std::uint64_t>::max();
EXPECT_FALSE(Evaluate(Normal(),h,1,2).status.IsOk());
h={}; h[0]={0,1,0,1}; f=Normal(); f[0].flux={{0,0}};
EXPECT_FALSE(Evaluate(f,h,1,2).status.IsOk());
f=Normal(); f[0].residual=1e200; f[0].correction=1e200;
f[0].older_residual=1; f[0].previous_residual=1;
const auto overflow=Evaluate(f,{},2,2);
EXPECT_FALSE(overflow.status.IsOk()); EXPECT_FALSE(overflow.field_pass);
f=Normal(); f[1]=f[0]; f[0].flux={{max,0}};
EXPECT_FALSE(Evaluate(f,{},1,2).status.IsOk());
Inputs inactive{}; auto r=Evaluate(inactive,{},0,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_TRUE(r.field_pass); EXPECT_FALSE(r.fields[0].field_pass.has_value());
}
TEST(HhtFieldConvergence, DecisionThresholdsBelowEqualAboveWithoutTolerance) {
auto f=Normal();
for(double x:{std::nextafter(.01,0.),.01,std::nextafter(.01,INFINITY)}) {
f[0].correction=x; auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.field_pass,x<=.01);
}
for(double x:{std::nextafter(.01,0.),.01,std::nextafter(.01,INFINITY)}) {
f=Normal(); f[0].residual=x; auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.field_pass,x<=.01);
}
for(double x:{std::nextafter(2.,0.),2.,std::nextafter(2.,INFINITY)}) {
f=Normal(); f[0].flux={{100,0}}; f[0].residual=x;
f[0].previous_residual=4; f[0].older_residual=8;
auto r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk());
// For below 2 the detector selects normal; equality/above selects Rp.
EXPECT_EQ(r.field_pass,x==2.);
}
}
TEST(HhtFieldConvergence, MixedIncidenceRetainsEveryElementScalarOccurrence) {
auto f=Normal(); f[0].flux={{6,0},{-2,0},{-1,0},{9,0},{0,0}};
// Three occurrences can share one global DOF and one belong to another.
// Node averaging would produce 6, signed assembly would produce 3 and 9.
auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux,3.6);
EXPECT_DOUBLE_EQ(*r.fields[0].maximum_flux,9);
}
TEST(HhtFieldConvergence, RemainingThresholdsHaveAdjacentRepresentableBoundaries) {
for (double x:{std::nextafter(.001,0.),.001,std::nextafter(.001,INFINITY)}) {
auto f=Normal(); Histories h{}; h[0]={2,1,2,1};
f[0].flux={{0,0}}; f[0].residual=.1; f[0].correction=x;
auto r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.field_pass,x<=.001);
}
for (double x:{std::nextafter(2e-5,0.),2e-5,std::nextafter(2e-5,INFINITY)}) {
auto f=Normal(); Histories h{}; h[0]={2,1,2,1};
f[0].flux={{0,0}}; f[0].residual=x; f[0].correction.reset();
auto r=Evaluate(f,h,0,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.field_pass,x<=2e-5);
}
for (double x:{std::nextafter(2e-8,0.),2e-8,std::nextafter(2e-8,INFINITY)}) {
auto f=Normal(); f[0].increment=x; f[0].correction=1;
auto r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.field_pass,x<2e-8);
f=Normal(); f[0].residual=x; f[0].correction.reset();
r=Evaluate(f,{},1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,x<=2e-8?Branch::kLinear:Branch::kNormal);
}
for (double x:{std::nextafter(.001,0.),.001,std::nextafter(.001,INFINITY)}) {
auto f=Normal(); Histories h{}; h[0]={0,0,100,1};
f[0].flux={{0,0},{x,0},{10,0}};
auto r=Evaluate(f,h,1,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_DOUBLE_EQ(*r.fields[0].spatial_flux,x<.001?10:(10+x)/2);
}
for (double x:{std::nextafter(2.,0.),2.,std::nextafter(2.,INFINITY)}) {
auto f=Normal(); f[0].flux={{100,0}}; f[0].residual=x;
f[0].previous_residual=4; f[0].older_residual=16;
auto r=Evaluate(f,{},10,2); ASSERT_TRUE(r.status.IsOk());
EXPECT_EQ(r.fields[0].branch,Branch::kNonquadratic);
EXPECT_EQ(r.field_pass,x<=2);
}
}
} // namespace
} // namespace fesa::hht_field_convergence