feat(linear-static-3d-euler-beam): step 24 - linear-static-cli
This commit is contained in:
KOKO\Mimi
@@ -0,0 +1,300 @@
|
||||
#include "fesa/analysis/linear_static_analysis.hpp"
|
||||
|
||||
#include "fesa/assembly/parallel_for.hpp"
|
||||
#include "fesa/results/results_writer.hpp"
|
||||
#include "fesa/solvers/linear/mkl_pardiso_solver.hpp"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <cstddef>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
class TempDirectory {
|
||||
public:
|
||||
explicit TempDirectory(const std::string& label) {
|
||||
static std::atomic<unsigned long long> sequence{0U};
|
||||
const auto tick = std::chrono::steady_clock::now()
|
||||
.time_since_epoch()
|
||||
.count();
|
||||
path_ = std::filesystem::temp_directory_path() /
|
||||
("fesa-step24-analysis-" + label + "-" +
|
||||
std::to_string(tick) + "-" +
|
||||
std::to_string(sequence.fetch_add(1U)));
|
||||
std::error_code error;
|
||||
if (!std::filesystem::create_directory(path_, error) || error) {
|
||||
throw std::runtime_error{"Unable to create the Step 24 analysis fixture."};
|
||||
}
|
||||
}
|
||||
|
||||
TempDirectory(const TempDirectory&) = delete;
|
||||
TempDirectory& operator=(const TempDirectory&) = delete;
|
||||
|
||||
~TempDirectory() {
|
||||
std::error_code ignored;
|
||||
std::filesystem::remove_all(path_, ignored);
|
||||
}
|
||||
|
||||
const std::filesystem::path& path() const noexcept { return path_; }
|
||||
|
||||
private:
|
||||
std::filesystem::path path_;
|
||||
};
|
||||
|
||||
void writeText(const std::filesystem::path& path, const std::string& text) {
|
||||
std::ofstream stream{path, std::ios::binary | std::ios::trunc};
|
||||
stream.write(text.data(), static_cast<std::streamsize>(text.size()));
|
||||
if (!stream) {
|
||||
throw std::runtime_error{"Unable to write the Step 24 analysis input."};
|
||||
}
|
||||
}
|
||||
|
||||
std::string axialDeck(const double rootUx, const double tipForce) {
|
||||
return R"inp(*Part, name=BeamPart
|
||||
*Node
|
||||
1, 0., 0., 0.
|
||||
2, 2., 0., 0.
|
||||
*Element, type=B33
|
||||
1, 1, 2
|
||||
*Elset, elset=BeamSet
|
||||
1
|
||||
*Beam General Section, elset=BeamSet, material=Steel, section=GENERAL
|
||||
2., 0.5, 0., 0.75, 0.25
|
||||
0., 1., 0.
|
||||
*End Part
|
||||
*Assembly, name=Assembly
|
||||
*Instance, name=Beam-1, part=BeamPart
|
||||
*End Instance
|
||||
*Nset, nset=Root, instance=Beam-1
|
||||
1
|
||||
*Nset, nset=Tip, instance=Beam-1
|
||||
2
|
||||
*End Assembly
|
||||
*Material, name=Steel
|
||||
*Elastic
|
||||
100., 0.25
|
||||
*Boundary
|
||||
Root, 1, 1, )inp" + std::to_string(rootUx) + R"inp(
|
||||
Root, 2, 6
|
||||
Tip, 2, 6
|
||||
*Step, name=Load, nlgeom=NO
|
||||
*Static
|
||||
0.1, 1., 0.01, 1.
|
||||
*Cload
|
||||
Tip, 1, )inp" + std::to_string(tipForce) + R"inp(
|
||||
*End Step
|
||||
)inp";
|
||||
}
|
||||
|
||||
// The pure Template Method spy makes the eight public lifecycle hooks observable
|
||||
// without coupling the ordering assertion to any solver backend.
|
||||
class SpyAnalysis final : public fesa::Analysis {
|
||||
public:
|
||||
const std::vector<std::string>& events() const noexcept { return events_; }
|
||||
|
||||
protected:
|
||||
fesa::Status initialize(const fesa::AnalysisRequest&) override {
|
||||
return record("initialize");
|
||||
}
|
||||
fesa::Status buildAnalysisModel() override {
|
||||
return record("build-analysis-model");
|
||||
}
|
||||
fesa::Status buildDofMapAndSparsePattern() override {
|
||||
return record("build-dof-map-and-sparse-pattern");
|
||||
}
|
||||
fesa::Status assembleAndPartitionStiffness() override {
|
||||
return record("assemble-and-partition-stiffness");
|
||||
}
|
||||
fesa::Status factorize() override { return record("factorize"); }
|
||||
fesa::Status assembleLoadsAndEffectiveRhs() override {
|
||||
return record("assemble-loads-and-effective-rhs");
|
||||
}
|
||||
fesa::Status substituteAndReconstruct() override {
|
||||
return record("substitute-and-reconstruct");
|
||||
}
|
||||
fesa::Status recoverAndWriteResults() override {
|
||||
return record("recover-and-write-results");
|
||||
}
|
||||
|
||||
private:
|
||||
fesa::Status record(const char* event) {
|
||||
events_.emplace_back(event);
|
||||
return fesa::Status::ok();
|
||||
}
|
||||
|
||||
std::vector<std::string> events_;
|
||||
};
|
||||
|
||||
// The solver spy records only the adapter-boundary operations. In particular,
|
||||
// solve() cannot conceal a second factorization call.
|
||||
class SpyLinearSolver final : public fesa::LinearSolver {
|
||||
public:
|
||||
explicit SpyLinearSolver(std::vector<std::string>& events)
|
||||
: events_{events} {}
|
||||
|
||||
fesa::Status factorize(const fesa::SparseMatrix&) override {
|
||||
++factorizeCalls_;
|
||||
events_.emplace_back("solver-factorize");
|
||||
return fesa::Status::ok();
|
||||
}
|
||||
|
||||
fesa::Status solve(
|
||||
const fesa::Vector& rhs, fesa::Vector& solution) const override {
|
||||
++solveCalls_;
|
||||
events_.emplace_back("solver-solve");
|
||||
for (std::size_t index = 0U;
|
||||
index < rhs.size() && index < solution.size(); ++index) {
|
||||
solution[index] = 0.0;
|
||||
}
|
||||
return fesa::Status::ok();
|
||||
}
|
||||
|
||||
int factorizeCalls() const noexcept { return factorizeCalls_; }
|
||||
int solveCalls() const noexcept { return solveCalls_; }
|
||||
|
||||
private:
|
||||
std::vector<std::string>& events_;
|
||||
int factorizeCalls_{0};
|
||||
mutable int solveCalls_{0};
|
||||
};
|
||||
|
||||
class SpyResultsWriter final : public fesa::ResultsWriter {
|
||||
public:
|
||||
explicit SpyResultsWriter(std::vector<std::string>& events)
|
||||
: events_{events} {}
|
||||
|
||||
fesa::Status write(
|
||||
const std::filesystem::path&,
|
||||
const fesa::Domain&,
|
||||
const fesa::AnalysisState&,
|
||||
const std::vector<fesa::Diagnostic>&) override {
|
||||
++writeCalls_;
|
||||
events_.emplace_back("writer-write");
|
||||
return fesa::Status::ok();
|
||||
}
|
||||
|
||||
int writeCalls() const noexcept { return writeCalls_; }
|
||||
|
||||
private:
|
||||
std::vector<std::string>& events_;
|
||||
int writeCalls_{0};
|
||||
};
|
||||
|
||||
class CapturingResultsWriter final : public fesa::ResultsWriter {
|
||||
public:
|
||||
fesa::Status write(
|
||||
const std::filesystem::path& outputPath,
|
||||
const fesa::Domain& domain,
|
||||
const fesa::AnalysisState& state,
|
||||
const std::vector<fesa::Diagnostic>& diagnostics) override {
|
||||
outputPath_ = outputPath;
|
||||
nodeCount_ = domain.nodes().size();
|
||||
state_ = std::make_unique<fesa::AnalysisState>(state);
|
||||
diagnostics_ = diagnostics;
|
||||
return fesa::Status::ok();
|
||||
}
|
||||
|
||||
const fesa::AnalysisState& state() const {
|
||||
if (!state_) {
|
||||
throw std::logic_error{"No AnalysisState was captured."};
|
||||
}
|
||||
return *state_;
|
||||
}
|
||||
|
||||
const std::filesystem::path& outputPath() const noexcept {
|
||||
return outputPath_;
|
||||
}
|
||||
std::size_t nodeCount() const noexcept { return nodeCount_; }
|
||||
const std::vector<fesa::Diagnostic>& diagnostics() const noexcept {
|
||||
return diagnostics_;
|
||||
}
|
||||
|
||||
private:
|
||||
std::filesystem::path outputPath_;
|
||||
std::size_t nodeCount_{0U};
|
||||
std::unique_ptr<fesa::AnalysisState> state_;
|
||||
std::vector<fesa::Diagnostic> diagnostics_;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(LinearStaticCli, FactorizesBeforeLoadAndSolvesWithoutRefactorization) {
|
||||
SpyAnalysis lifecycle;
|
||||
const fesa::AnalysisRequest emptyRequest{};
|
||||
ASSERT_TRUE(lifecycle.run(emptyRequest).isOk());
|
||||
EXPECT_EQ(
|
||||
lifecycle.events(),
|
||||
(std::vector<std::string>{
|
||||
"initialize",
|
||||
"build-analysis-model",
|
||||
"build-dof-map-and-sparse-pattern",
|
||||
"assemble-and-partition-stiffness",
|
||||
"factorize",
|
||||
"assemble-loads-and-effective-rhs",
|
||||
"substitute-and-reconstruct",
|
||||
"recover-and-write-results"}));
|
||||
|
||||
TempDirectory directory{"order"};
|
||||
const auto input = directory.path() / "order.inp";
|
||||
const auto output = directory.path() / "results.h5";
|
||||
writeText(input, axialDeck(0.0, 0.0));
|
||||
|
||||
std::vector<std::string> adapterEvents;
|
||||
fesa::SerialParallelFor serial;
|
||||
SpyLinearSolver solver{adapterEvents};
|
||||
SpyResultsWriter writer{adapterEvents};
|
||||
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
|
||||
|
||||
ASSERT_TRUE(analysis.run({input, output}).isOk());
|
||||
EXPECT_EQ(solver.factorizeCalls(), 1);
|
||||
EXPECT_EQ(solver.solveCalls(), 1);
|
||||
EXPECT_EQ(writer.writeCalls(), 1);
|
||||
EXPECT_EQ(
|
||||
adapterEvents,
|
||||
(std::vector<std::string>{
|
||||
"solver-factorize", "solver-solve", "writer-write"}));
|
||||
}
|
||||
|
||||
TEST(LinearStaticCli, RealPipelineHandlesAnalyticalAndNonzeroPrescription) {
|
||||
TempDirectory directory{"analytical"};
|
||||
const auto input = directory.path() / "prescribed-axial.inp";
|
||||
const auto output = directory.path() / "captured-results.h5";
|
||||
writeText(input, axialDeck(0.1, 10.0));
|
||||
|
||||
fesa::SerialParallelFor serial;
|
||||
fesa::MklPardisoSolver solver;
|
||||
CapturingResultsWriter writer;
|
||||
fesa::LinearStaticAnalysis analysis{serial, solver, writer};
|
||||
|
||||
const auto status = analysis.run({input, output});
|
||||
ASSERT_TRUE(status.isOk());
|
||||
EXPECT_EQ(writer.outputPath(), output);
|
||||
EXPECT_EQ(writer.nodeCount(), 2U);
|
||||
EXPECT_TRUE(writer.diagnostics().empty());
|
||||
|
||||
const auto& state = writer.state();
|
||||
ASSERT_EQ(state.displacement().size(), 12U);
|
||||
EXPECT_EQ(state.identity().stepName, "Step-1");
|
||||
EXPECT_EQ(state.identity().frameIndex, 0U);
|
||||
|
||||
// EA/L = 100 for this fixture, so u_tip = 0.1 + 10/100 = 0.2.
|
||||
EXPECT_NEAR(state.displacement()[0U], 0.1, 1.0e-12);
|
||||
EXPECT_NEAR(state.displacement()[6U], 0.2, 2.0e-10);
|
||||
EXPECT_NEAR(state.externalForce()[6U], 10.0, 1.0e-12);
|
||||
EXPECT_NEAR(state.internalForce()[0U], -10.0, 1.0e-9);
|
||||
EXPECT_NEAR(state.internalForce()[6U], 10.0, 1.0e-9);
|
||||
EXPECT_NEAR(state.reaction()[0U], -10.0, 1.0e-9);
|
||||
EXPECT_NEAR(state.residual()[6U], 0.0, 1.0e-9);
|
||||
EXPECT_EQ(state.endpointResults().size(), 2U);
|
||||
EXPECT_EQ(state.gaussResults().size(), 2U);
|
||||
EXPECT_EQ(state.stressResults().size(), 2U);
|
||||
}
|
||||
Reference in New Issue
Block a user