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

feat(cpp-object-oriented-modular-refactoring): step 3 - foundation-google-style

Browse Source
This commit is contained in:
KOKO\Mimi
2026-08-16 04:26:14 +09:00
parent 2628ed3488
commit 042edadffb
93 changed files with 3144 additions and 3175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/assembly/load_assembler_test.cpp
+62 -62
View File
@@ -54,25 +54,25 @@ LoadFixture makeFixture(
{source, 20U}}};
auto domainResult = fesa::Domain::create(std::move(definition));
if (!domainResult.hasValue()) {
if (!domainResult.HasValue()) {
throw std::runtime_error{"Load fixture Domain construction failed."};
}
auto domain = std::make_unique<fesa::Domain>(
std::move(domainResult.value()));
std::move(domainResult.Value()));
auto modelResult = fesa::AnalysisModel::create(*domain);
if (!modelResult.hasValue()) {
if (!modelResult.HasValue()) {
throw std::runtime_error{"Load fixture AnalysisModel construction failed."};
}
auto model = std::make_unique<fesa::AnalysisModel>(
std::move(modelResult.value()));
std::move(modelResult.Value()));
auto dofResult = fesa::DofManager::create(*model);
if (!dofResult.hasValue()) {
if (!dofResult.HasValue()) {
throw std::runtime_error{"Load fixture DofManager construction failed."};
}
auto dofs = std::make_unique<fesa::DofManager>(
std::move(dofResult.value()));
std::move(dofResult.Value()));
return {std::move(domain), std::move(model), std::move(dofs)};
}
@@ -117,25 +117,25 @@ LoadFixture makeShellFixture(
{source, 20U}}};
auto domainResult = fesa::Domain::create(std::move(definition));
if (!domainResult.hasValue()) {
if (!domainResult.HasValue()) {
throw std::runtime_error{"Shell load fixture Domain construction failed."};
}
auto domain = std::make_unique<fesa::Domain>(
std::move(domainResult.value()));
std::move(domainResult.Value()));
auto modelResult = fesa::AnalysisModel::create(*domain);
if (!modelResult.hasValue()) {
if (!modelResult.HasValue()) {
throw std::runtime_error{"Shell load fixture AnalysisModel construction failed."};
}
auto model = std::make_unique<fesa::AnalysisModel>(
std::move(modelResult.value()));
std::move(modelResult.Value()));
auto dofResult = fesa::DofManager::create(*model);
if (!dofResult.hasValue()) {
if (!dofResult.HasValue()) {
throw std::runtime_error{"Shell load fixture DofManager construction failed."};
}
auto dofs = std::make_unique<fesa::DofManager>(
std::move(dofResult.value()));
std::move(dofResult.Value()));
return {std::move(domain), std::move(model), std::move(dofs)};
}
@@ -164,21 +164,21 @@ fesa::SparseMatrix makeDenseSparse(
pattern.rowOffsets.push_back(pattern.columnIndices.size());
}
auto result = fesa::SparseMatrix::fromCoo(
auto result = fesa::SparseMatrix::FromCoo(
rows, columns, std::move(contributions), pattern);
if (!result.hasValue()) {
if (!result.HasValue()) {
throw std::runtime_error{"Sparse fixture construction failed."};
}
return std::move(result.value());
return std::move(result.Value());
}
void expectFailureCode(
const fesa::Result<fesa::Vector>& result,
const std::string& code) {
ASSERT_FALSE(result.hasValue());
EXPECT_EQ(result.status().failureCategory(), fesa::FailureCategory::model);
ASSERT_EQ(result.status().diagnostics().size(), 1U);
EXPECT_EQ(result.status().diagnostics()[0U].code, code);
ASSERT_FALSE(result.HasValue());
EXPECT_EQ(result.GetStatus().Category(), fesa::FailureCategory::kModel);
ASSERT_EQ(result.GetStatus().Diagnostics().size(), 1U);
EXPECT_EQ(result.GetStatus().Diagnostics()[0U].code, code);
}
} // namespace
@@ -198,16 +198,16 @@ TEST(LoadAssembly, AssemblesNodeSetAndSixComponentLoads) {
auto result = fesa::LoadAssembler::assembleFullNodalLoad(
*fixture.model, *fixture.dofs);
ASSERT_TRUE(result.hasValue());
ASSERT_EQ(result.value().size(), 12U);
ASSERT_TRUE(result.HasValue());
ASSERT_EQ(result.Value().Size(), 12U);
EXPECT_EQ(
std::vector<double>(result.value().data(), result.value().data() + 12U),
std::vector<double>(result.Value().Data(), result.Value().Data() + 12U),
(std::vector<double>{
1.0, 2.0, 0.0, -4.0, 5.0, 0.0,
1.0, 0.0, 3.0, 0.0, 5.0, 6.0}));
EXPECT_EQ(fixture.dofs->constrainedDofs(),
(std::vector<std::size_t>{0U}));
EXPECT_DOUBLE_EQ(result.value()[0U], 1.0);
EXPECT_DOUBLE_EQ(result.Value()[0U], 1.0);
}
TEST(LoadAssembly, AccumulatesSignedLoadsInSourceOrder) {
@@ -231,10 +231,10 @@ TEST(LoadAssembly, AccumulatesSignedLoadsInSourceOrder) {
*firstOrder.model, *firstOrder.dofs);
auto second = fesa::LoadAssembler::assembleFullNodalLoad(
*secondOrder.model, *secondOrder.dofs);
ASSERT_TRUE(first.hasValue());
ASSERT_TRUE(second.hasValue());
EXPECT_DOUBLE_EQ(first.value()[0U], 1.0);
EXPECT_DOUBLE_EQ(second.value()[0U], 0.0);
ASSERT_TRUE(first.HasValue());
ASSERT_TRUE(second.HasValue());
EXPECT_DOUBLE_EQ(first.Value()[0U], 1.0);
EXPECT_DOUBLE_EQ(second.Value()[0U], 0.0);
}
// MITC4-LOAD-001
@@ -257,10 +257,10 @@ TEST(LoadAssembly, AggregatesAllSixGlobalShellLoadComponentsInSourceOrder) {
const auto result = fesa::LoadAssembler::assembleFullNodalLoad(
*fixture.model, *fixture.dofs);
ASSERT_TRUE(result.hasValue());
ASSERT_EQ(result.value().size(), 24U);
ASSERT_TRUE(result.HasValue());
ASSERT_EQ(result.Value().Size(), 24U);
EXPECT_EQ(
std::vector<double>(result.value().data(), result.value().data() + 6U),
std::vector<double>(result.Value().Data(), result.Value().Data() + 6U),
(std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0, 0.0}));
}
@@ -279,10 +279,10 @@ TEST(LoadAssembly, AcceptsExactlyZeroAggregateShellMoment) {
const auto result = fesa::LoadAssembler::assembleFullNodalLoad(
*fixture.model, *fixture.dofs);
ASSERT_TRUE(result.hasValue());
EXPECT_DOUBLE_EQ(result.value()[3U], 0.0);
EXPECT_DOUBLE_EQ(result.value()[4U], 0.0);
EXPECT_DOUBLE_EQ(result.value()[5U], 0.0);
ASSERT_TRUE(result.HasValue());
EXPECT_DOUBLE_EQ(result.Value()[3U], 0.0);
EXPECT_DOUBLE_EQ(result.Value()[4U], 0.0);
EXPECT_DOUBLE_EQ(result.Value()[5U], 0.0);
}
// MITC4-LOAD-003
@@ -302,15 +302,15 @@ TEST(LoadAssembly, EnforcesAggregateShellMomentDirectorProjectionThreshold) {
const auto rejected = fesa::LoadAssembler::assembleFullNodalLoad(
*rejectedFixture.model, *rejectedFixture.dofs);
ASSERT_TRUE(accepted.hasValue());
ASSERT_FALSE(rejected.hasValue());
EXPECT_EQ(rejected.status().failureCategory(), fesa::FailureCategory::model);
ASSERT_EQ(rejected.status().diagnostics().size(), 1U);
ASSERT_TRUE(accepted.HasValue());
ASSERT_FALSE(rejected.HasValue());
EXPECT_EQ(rejected.GetStatus().Category(), fesa::FailureCategory::kModel);
ASSERT_EQ(rejected.GetStatus().Diagnostics().size(), 1U);
EXPECT_EQ(
rejected.status().diagnostics()[0U].code,
rejected.GetStatus().Diagnostics()[0U].code,
"unsupported-drilling-load");
EXPECT_EQ(rejected.status().diagnostics()[0U].keyword, "CLOAD");
EXPECT_EQ(rejected.status().diagnostics()[0U].entityIdentity, "10");
EXPECT_EQ(rejected.GetStatus().Diagnostics()[0U].keyword, "CLOAD");
EXPECT_EQ(rejected.GetStatus().Diagnostics()[0U].entity_identity, "10");
}
// MITC4-LOAD-004
@@ -323,11 +323,11 @@ TEST(LoadAssembly, RejectsDrillingMomentBeforeEffectiveRhsCanBeFormed) {
const auto rejected = fesa::LoadAssembler::assembleFullNodalLoad(
*fixture.model, *fixture.dofs);
ASSERT_FALSE(rejected.hasValue());
EXPECT_EQ(rejected.status().failureCategory(), fesa::FailureCategory::model);
ASSERT_EQ(rejected.status().diagnostics().size(), 1U);
ASSERT_FALSE(rejected.HasValue());
EXPECT_EQ(rejected.GetStatus().Category(), fesa::FailureCategory::kModel);
ASSERT_EQ(rejected.GetStatus().Diagnostics().size(), 1U);
EXPECT_EQ(
rejected.status().diagnostics()[0U].code,
rejected.GetStatus().Diagnostics()[0U].code,
"unsupported-drilling-load");
}
@@ -346,7 +346,7 @@ TEST(LoadAssembly, FormsNonzeroPrescribedEffectiveRhs) {
{"10", 6, 40.0, {source, 35U}}});
auto full = fesa::LoadAssembler::assembleFullNodalLoad(
*fixture.model, *fixture.dofs);
ASSERT_TRUE(full.hasValue());
ASSERT_TRUE(full.HasValue());
const auto kfc = makeDenseSparse(
4U,
2U,
@@ -356,11 +356,11 @@ TEST(LoadAssembly, FormsNonzeroPrescribedEffectiveRhs) {
0.5, -1.0});
auto rhs = fesa::LoadAssembler::effectiveFreeRhs(
full.value(), kfc, fixture.dofs->prescribedValues(), *fixture.dofs);
ASSERT_TRUE(rhs.hasValue());
ASSERT_EQ(rhs.value().size(), 4U);
full.Value(), kfc, fixture.dofs->prescribedValues(), *fixture.dofs);
ASSERT_TRUE(rhs.HasValue());
ASSERT_EQ(rhs.Value().Size(), 4U);
EXPECT_EQ(
std::vector<double>(rhs.value().data(), rhs.value().data() + 4U),
std::vector<double>(rhs.Value().Data(), rhs.Value().Data() + 4U),
(std::vector<double>{10.0, 18.0, 39.0, 38.0}));
}
@@ -469,22 +469,22 @@ TEST(LoadAssembly, ZeroLoadsRemainZero) {
{{"10", 3, 0.0, {source, 30U}}});
auto full = fesa::LoadAssembler::assembleFullNodalLoad(
*freeFixture.model, *freeFixture.dofs);
ASSERT_TRUE(full.hasValue());
ASSERT_TRUE(full.HasValue());
EXPECT_TRUE(std::all_of(
full.value().data(),
full.value().data() + full.value().size(),
full.Value().Data(),
full.Value().Data() + full.Value().Size(),
[](const double value) { return value == 0.0; }));
const auto noConstrainedColumns = makeDenseSparse(6U, 0U, {});
auto freeRhs = fesa::LoadAssembler::effectiveFreeRhs(
full.value(),
full.Value(),
noConstrainedColumns,
freeFixture.dofs->prescribedValues(),
*freeFixture.dofs);
ASSERT_TRUE(freeRhs.hasValue());
EXPECT_EQ(freeRhs.value().size(), 6U);
ASSERT_TRUE(freeRhs.HasValue());
EXPECT_EQ(freeRhs.Value().Size(), 6U);
EXPECT_TRUE(std::all_of(
freeRhs.value().data(),
freeRhs.value().data() + freeRhs.value().size(),
freeRhs.Value().Data(),
freeRhs.Value().Data() + freeRhs.Value().Size(),
[](const double value) { return value == 0.0; }));
auto constrainedFixture = makeFixture(
@@ -494,13 +494,13 @@ TEST(LoadAssembly, ZeroLoadsRemainZero) {
{});
auto constrainedFull = fesa::LoadAssembler::assembleFullNodalLoad(
*constrainedFixture.model, *constrainedFixture.dofs);
ASSERT_TRUE(constrainedFull.hasValue());
ASSERT_TRUE(constrainedFull.HasValue());
const auto noFreeRows = makeDenseSparse(0U, 6U, {});
auto constrainedRhs = fesa::LoadAssembler::effectiveFreeRhs(
constrainedFull.value(),
constrainedFull.Value(),
noFreeRows,
constrainedFixture.dofs->prescribedValues(),
*constrainedFixture.dofs);
ASSERT_TRUE(constrainedRhs.hasValue());
EXPECT_EQ(constrainedRhs.value().size(), 0U);
ASSERT_TRUE(constrainedRhs.HasValue());
EXPECT_EQ(constrainedRhs.Value().Size(), 0U);
}
tests/unit/assembly/sparse_assembler_test.cpp
+84 -84
View File
@@ -115,10 +115,10 @@ fesa::Result<fesa::Mitc4Stiffness> directShellStiffness(
directors,
domain.shellSections().at(definition.sectionIndex),
domain.materials().at(definition.materialIndex));
if (!shell.hasValue()) {
return fesa::Result<fesa::Mitc4Stiffness>::failure(shell.status());
if (!shell.HasValue()) {
return fesa::Result<fesa::Mitc4Stiffness>::Failure(shell.GetStatus());
}
return shell.value().stiffness();
return shell.Value().stiffness();
}
fesa::Result<fesa::SparseMatrix> assembleShell(
@@ -127,19 +127,19 @@ fesa::Result<fesa::SparseMatrix> assembleShell(
const bool twoElements = false) {
auto domain = fesa::Domain::create(
makeShellDefinition(sourceType, twoElements));
if (!domain.hasValue()) {
return fesa::Result<fesa::SparseMatrix>::failure(domain.status());
if (!domain.HasValue()) {
return fesa::Result<fesa::SparseMatrix>::Failure(domain.GetStatus());
}
auto model = fesa::AnalysisModel::create(domain.value());
if (!model.hasValue()) {
return fesa::Result<fesa::SparseMatrix>::failure(model.status());
auto model = fesa::AnalysisModel::create(domain.Value());
if (!model.HasValue()) {
return fesa::Result<fesa::SparseMatrix>::Failure(model.GetStatus());
}
auto dofs = fesa::DofManager::create(model.value());
if (!dofs.hasValue()) {
return fesa::Result<fesa::SparseMatrix>::failure(dofs.status());
auto dofs = fesa::DofManager::create(model.Value());
if (!dofs.HasValue()) {
return fesa::Result<fesa::SparseMatrix>::Failure(dofs.GetStatus());
}
return fesa::SparseAssembler::assembleStiffness(
model.value(), dofs.value(), parallelFor);
model.Value(), dofs.Value(), parallelFor);
}
template<class T>
@@ -154,14 +154,14 @@ double entry(
const fesa::SparseMatrix& matrix,
const std::size_t row,
const std::size_t column) {
const auto begin = matrix.columnIndices().begin() + matrix.rowOffsets()[row];
const auto end = matrix.columnIndices().begin() + matrix.rowOffsets()[row + 1U];
const auto begin = matrix.ColumnIndices().begin() + matrix.RowOffsets()[row];
const auto end = matrix.ColumnIndices().begin() + matrix.RowOffsets()[row + 1U];
const auto found = std::lower_bound(begin, end, column);
if (found == end || *found != column) {
return 0.0;
}
return matrix.values()[static_cast<std::size_t>(
std::distance(matrix.columnIndices().begin(), found))];
return matrix.Values()[static_cast<std::size_t>(
std::distance(matrix.ColumnIndices().begin(), found))];
}
class ReverseParallelFor final : public fesa::ParallelFor {
@@ -192,66 +192,66 @@ private:
void expectByteIdentical(
const fesa::SparseMatrix& actual,
const fesa::SparseMatrix& expected) {
EXPECT_TRUE(byteIdentical(actual.rowOffsets(), expected.rowOffsets()));
EXPECT_TRUE(byteIdentical(actual.columnIndices(), expected.columnIndices()));
EXPECT_TRUE(byteIdentical(actual.values(), expected.values()));
EXPECT_TRUE(byteIdentical(actual.RowOffsets(), expected.RowOffsets()));
EXPECT_TRUE(byteIdentical(actual.ColumnIndices(), expected.ColumnIndices()));
EXPECT_TRUE(byteIdentical(actual.Values(), expected.Values()));
}
TEST(SparseAssembly, SerialTbbAndRepeatedRunsAreByteIdentical) {
auto domainResult = fesa::Domain::create(makeDefinition());
ASSERT_TRUE(domainResult.hasValue());
auto modelResult = fesa::AnalysisModel::create(domainResult.value());
ASSERT_TRUE(modelResult.hasValue());
auto dofsResult = fesa::DofManager::create(modelResult.value());
ASSERT_TRUE(dofsResult.hasValue());
ASSERT_TRUE(domainResult.HasValue());
auto modelResult = fesa::AnalysisModel::create(domainResult.Value());
ASSERT_TRUE(modelResult.HasValue());
auto dofsResult = fesa::DofManager::create(modelResult.Value());
ASSERT_TRUE(dofsResult.HasValue());
fesa::SerialParallelFor serialExecutor;
fesa::TbbParallelFor tbbExecutor;
ReverseParallelFor reverseExecutor;
auto serial = fesa::SparseAssembler::assembleStiffness(
modelResult.value(), dofsResult.value(), serialExecutor);
modelResult.Value(), dofsResult.Value(), serialExecutor);
auto tbb = fesa::SparseAssembler::assembleStiffness(
modelResult.value(), dofsResult.value(), tbbExecutor);
modelResult.Value(), dofsResult.Value(), tbbExecutor);
auto reversed = fesa::SparseAssembler::assembleStiffness(
modelResult.value(), dofsResult.value(), reverseExecutor);
ASSERT_TRUE(serial.hasValue());
ASSERT_TRUE(tbb.hasValue());
ASSERT_TRUE(reversed.hasValue());
modelResult.Value(), dofsResult.Value(), reverseExecutor);
ASSERT_TRUE(serial.HasValue());
ASSERT_TRUE(tbb.HasValue());
ASSERT_TRUE(reversed.HasValue());
EXPECT_EQ(reverseExecutor.calls(), 1U);
EXPECT_EQ(reverseExecutor.observedCount(), 2U);
EXPECT_EQ(serial.value().rows(), 18U);
EXPECT_EQ(serial.value().columns(), 18U);
EXPECT_EQ(serial.value().rowOffsets(), dofsResult.value().sparsePattern().rowOffsets);
EXPECT_EQ(serial.Value().Rows(), 18U);
EXPECT_EQ(serial.Value().Columns(), 18U);
EXPECT_EQ(serial.Value().RowOffsets(), dofsResult.Value().sparsePattern().rowOffsets);
EXPECT_EQ(
serial.value().columnIndices(),
dofsResult.value().sparsePattern().columnIndices);
EXPECT_TRUE(serial.value().validate().isOk());
expectByteIdentical(tbb.value(), serial.value());
expectByteIdentical(reversed.value(), serial.value());
serial.Value().ColumnIndices(),
dofsResult.Value().sparsePattern().columnIndices);
EXPECT_TRUE(serial.Value().Validate().IsOk());
expectByteIdentical(tbb.Value(), serial.Value());
expectByteIdentical(reversed.Value(), serial.Value());
for (std::size_t repetition = 0U; repetition < 8U; ++repetition) {
auto repeated = fesa::SparseAssembler::assembleStiffness(
modelResult.value(), dofsResult.value(), tbbExecutor);
ASSERT_TRUE(repeated.hasValue());
expectByteIdentical(repeated.value(), serial.value());
modelResult.Value(), dofsResult.Value(), tbbExecutor);
ASSERT_TRUE(repeated.HasValue());
expectByteIdentical(repeated.Value(), serial.Value());
}
for (std::size_t row = 0U; row < serial.value().rows(); ++row) {
for (std::size_t row = 0U; row < serial.Value().Rows(); ++row) {
for (std::size_t column = 0U;
column < serial.value().columns();
column < serial.Value().Columns();
++column) {
EXPECT_DOUBLE_EQ(
entry(serial.value(), row, column),
entry(serial.value(), column, row));
entry(serial.Value(), row, column),
entry(serial.Value(), column, row));
}
}
EXPECT_NEAR(entry(serial.value(), 0U, 0U), 120.0, 1.0e-12);
EXPECT_NEAR(entry(serial.value(), 0U, 6U), -120.0, 1.0e-12);
EXPECT_NEAR(entry(serial.value(), 6U, 6U), 200.0, 1.0e-12);
EXPECT_NEAR(entry(serial.value(), 6U, 12U), -80.0, 1.0e-12);
EXPECT_NEAR(entry(serial.value(), 12U, 12U), 80.0, 1.0e-12);
EXPECT_NEAR(entry(serial.Value(), 0U, 0U), 120.0, 1.0e-12);
EXPECT_NEAR(entry(serial.Value(), 0U, 6U), -120.0, 1.0e-12);
EXPECT_NEAR(entry(serial.Value(), 6U, 6U), 200.0, 1.0e-12);
EXPECT_NEAR(entry(serial.Value(), 6U, 12U), -80.0, 1.0e-12);
EXPECT_NEAR(entry(serial.Value(), 12U, 12U), 80.0, 1.0e-12);
}
TEST(
@@ -259,38 +259,38 @@ TEST(
AssemblesFourNodeTwentyFourDofKernelAndPreservesDiagonalSlots) {
auto domain = fesa::Domain::create(
makeShellDefinition(fesa::ShellSourceElementType::s4));
ASSERT_TRUE(domain.hasValue());
auto model = fesa::AnalysisModel::create(domain.value());
ASSERT_TRUE(model.hasValue());
auto dofs = fesa::DofManager::create(model.value());
ASSERT_TRUE(dofs.hasValue());
ASSERT_TRUE(domain.HasValue());
auto model = fesa::AnalysisModel::create(domain.Value());
ASSERT_TRUE(model.HasValue());
auto dofs = fesa::DofManager::create(model.Value());
ASSERT_TRUE(dofs.HasValue());
fesa::SerialParallelFor serialExecutor;
auto assembled = fesa::SparseAssembler::assembleStiffness(
model.value(), dofs.value(), serialExecutor);
auto expected = directShellStiffness(domain.value(), 0U);
ASSERT_TRUE(assembled.hasValue());
ASSERT_TRUE(expected.hasValue());
model.Value(), dofs.Value(), serialExecutor);
auto expected = directShellStiffness(domain.Value(), 0U);
ASSERT_TRUE(assembled.HasValue());
ASSERT_TRUE(expected.HasValue());
EXPECT_EQ(assembled.value().rows(), 24U);
EXPECT_EQ(assembled.value().columns(), 24U);
EXPECT_EQ(assembled.value().values().size(), 24U * 24U);
EXPECT_EQ(assembled.Value().Rows(), 24U);
EXPECT_EQ(assembled.Value().Columns(), 24U);
EXPECT_EQ(assembled.Value().Values().size(), 24U * 24U);
EXPECT_EQ(
assembled.value().rowOffsets(),
dofs.value().sparsePattern().rowOffsets);
assembled.Value().RowOffsets(),
dofs.Value().sparsePattern().rowOffsets);
EXPECT_EQ(
assembled.value().columnIndices(),
dofs.value().sparsePattern().columnIndices);
assembled.Value().ColumnIndices(),
dofs.Value().sparsePattern().columnIndices);
for (std::size_t row = 0U; row < 24U; ++row) {
const auto begin = assembled.value().columnIndices().begin() +
assembled.value().rowOffsets()[row];
const auto end = assembled.value().columnIndices().begin() +
assembled.value().rowOffsets()[row + 1U];
const auto begin = assembled.Value().ColumnIndices().begin() +
assembled.Value().RowOffsets()[row];
const auto end = assembled.Value().ColumnIndices().begin() +
assembled.Value().RowOffsets()[row + 1U];
EXPECT_NE(std::lower_bound(begin, end, row), end);
for (std::size_t column = 0U; column < 24U; ++column) {
EXPECT_DOUBLE_EQ(
entry(assembled.value(), row, column),
expected.value().stabilizedGlobal24(row, column));
entry(assembled.Value(), row, column),
expected.Value().stabilizedGlobal24(row, column));
}
}
}
@@ -305,19 +305,19 @@ TEST(SparseAssembly, ShellSerialTbbReverseAndRepeatedRunsAreByteIdentical) {
fesa::ShellSourceElementType::s4, tbbExecutor, true);
auto reversed = assembleShell(
fesa::ShellSourceElementType::s4, reverseExecutor, true);
ASSERT_TRUE(serial.hasValue());
ASSERT_TRUE(tbb.hasValue());
ASSERT_TRUE(reversed.hasValue());
ASSERT_TRUE(serial.HasValue());
ASSERT_TRUE(tbb.HasValue());
ASSERT_TRUE(reversed.HasValue());
EXPECT_EQ(reverseExecutor.calls(), 1U);
EXPECT_EQ(reverseExecutor.observedCount(), 2U);
expectByteIdentical(tbb.value(), serial.value());
expectByteIdentical(reversed.value(), serial.value());
expectByteIdentical(tbb.Value(), serial.Value());
expectByteIdentical(reversed.Value(), serial.Value());
for (std::size_t repetition = 0U; repetition < 8U; ++repetition) {
auto repeated = assembleShell(
fesa::ShellSourceElementType::s4, tbbExecutor, true);
ASSERT_TRUE(repeated.hasValue());
expectByteIdentical(repeated.value(), serial.value());
ASSERT_TRUE(repeated.HasValue());
expectByteIdentical(repeated.Value(), serial.Value());
}
}
@@ -327,13 +327,13 @@ TEST(SparseAssembly, S4AndS4rSemanticFixturesAssembleIdenticalStiffness) {
fesa::ShellSourceElementType::s4, serialExecutor);
auto s4r = assembleShell(
fesa::ShellSourceElementType::s4r, serialExecutor);
ASSERT_TRUE(s4.hasValue());
ASSERT_TRUE(s4r.hasValue());
ASSERT_TRUE(s4.HasValue());
ASSERT_TRUE(s4r.HasValue());
EXPECT_TRUE(std::any_of(
s4.value().values().begin(),
s4.value().values().end(),
s4.Value().Values().begin(),
s4.Value().Values().end(),
[](const double value) { return value != 0.0; }));
expectByteIdentical(s4r.value(), s4.value());
expectByteIdentical(s4r.Value(), s4.Value());
}
} // namespace