feat(shell-surface-pressure-load): step 4 - integrate-linear-shell-pressure
This commit is contained in:
KOKO\Mimi
@@ -0,0 +1,272 @@
|
||||
#include "fesa/analysis/linear_static_analysis.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <hdf5.h>
|
||||
|
||||
#include "fesa/analysis/analysis.h"
|
||||
#include "fesa/app/fesa_application.h"
|
||||
#include "fesa/assembly/parallel_for.h"
|
||||
#include "fesa/results/results_writer.h"
|
||||
#include "fesa/solvers/linear/mkl_pardiso_solver.h"
|
||||
|
||||
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-surface-pressure-linear-" + 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 surface pressure 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 surface pressure input."};
|
||||
}
|
||||
}
|
||||
|
||||
std::string ShellDeck(const std::string& source_type,
|
||||
const std::string& connectivity,
|
||||
const bool prescribed_displacement,
|
||||
const bool with_pressure) {
|
||||
std::string boundary;
|
||||
if (prescribed_displacement) {
|
||||
boundary = R"inp(*Boundary
|
||||
N1, 1, 6
|
||||
N2, 1, 2
|
||||
N2, 3, 3, 5.0
|
||||
N2, 4, 6
|
||||
N3, 1, 6
|
||||
N4, 1, 6
|
||||
)inp";
|
||||
} else {
|
||||
boundary = "*Boundary\nAll, 1, 6\n";
|
||||
}
|
||||
const std::string surface = with_pressure
|
||||
? "*Surface, TYPE=ELEMENT, NAME=Pressure\n"
|
||||
"Shell-1.1, SPOS\n"
|
||||
: "";
|
||||
const std::string dsload = with_pressure
|
||||
? "*Dsload\nPressure, P, 4.0\n"
|
||||
: "";
|
||||
return std::string{R"inp(*Part, name=ShellPart
|
||||
*Node
|
||||
1, 0., 0., 0.
|
||||
2, 1., 0., 0.
|
||||
3, 1., 1., 0.
|
||||
4, 0., 1., 0.
|
||||
*Element, type=)inp"} +
|
||||
source_type + "\n1, " + connectivity + R"inp(
|
||||
*Elset, elset=ShellSet
|
||||
1
|
||||
*Shell Section, elset=ShellSet, material=Steel
|
||||
0.1
|
||||
*End Part
|
||||
*Assembly, name=Assembly
|
||||
*Instance, name=Shell-1, part=ShellPart
|
||||
*End Instance
|
||||
)inp" +
|
||||
surface + R"inp(*Nset, nset=N1, instance=Shell-1
|
||||
1
|
||||
*Nset, nset=N2, instance=Shell-1
|
||||
2
|
||||
*Nset, nset=N3, instance=Shell-1
|
||||
3
|
||||
*Nset, nset=N4, instance=Shell-1
|
||||
4
|
||||
*Nset, nset=All, instance=Shell-1
|
||||
1, 2, 3, 4
|
||||
*End Assembly
|
||||
*Material, name=Steel
|
||||
*Elastic
|
||||
1000., 0.25
|
||||
)inp" +
|
||||
boundary + R"inp(*Step, name=Load, nlgeom=NO
|
||||
*Static
|
||||
0.1, 1., 0.01, 1.
|
||||
)inp" +
|
||||
dsload + "*End Step\n";
|
||||
}
|
||||
|
||||
class CapturingResultsWriter final : public fesa::ResultsWriter {
|
||||
public:
|
||||
fesa::Status Write(const std::filesystem::path&, const fesa::Domain&,
|
||||
const fesa::AnalysisState& state,
|
||||
const std::vector<fesa::Diagnostic>&) override {
|
||||
state_ = std::make_unique<fesa::AnalysisState>(state);
|
||||
return fesa::Status::Ok();
|
||||
}
|
||||
|
||||
const fesa::AnalysisState& State() const {
|
||||
if (!state_) {
|
||||
throw std::logic_error{"No linear state was captured."};
|
||||
}
|
||||
return *state_;
|
||||
}
|
||||
|
||||
private:
|
||||
std::unique_ptr<fesa::AnalysisState> state_;
|
||||
};
|
||||
|
||||
fesa::AnalysisState RunLinear(const std::filesystem::path& input,
|
||||
const std::filesystem::path& output) {
|
||||
fesa::SerialParallelFor serial;
|
||||
fesa::MklPardisoSolver solver;
|
||||
CapturingResultsWriter writer;
|
||||
std::unique_ptr<fesa::Analysis> analysis =
|
||||
std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
|
||||
const fesa::Status status = analysis->Run({input, output});
|
||||
if (!status.IsOk()) {
|
||||
throw std::runtime_error{status.Diagnostics().empty()
|
||||
? "Linear pressure analysis failed."
|
||||
: status.Diagnostics().front().code};
|
||||
}
|
||||
return writer.State();
|
||||
}
|
||||
|
||||
std::array<double, 3> SumTranslation(const fesa::Vector& values) {
|
||||
std::array<double, 3> sum{};
|
||||
for (std::size_t node = 0U; node < values.Size() / 6U; ++node) {
|
||||
for (std::size_t component = 0U; component < 3U; ++component) {
|
||||
sum[component] += values[node * 6U + component];
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(LinearShellSurfacePressure,
|
||||
UsesReferenceNormalAndAreaAfterPrescribedDisplacement) {
|
||||
TempDirectory directory{"reference-configuration"};
|
||||
const auto input = directory.Path() / "prescribed.inp";
|
||||
WriteText(input, ShellDeck("S4", "1, 2, 3, 4", true, true));
|
||||
|
||||
const fesa::AnalysisState state =
|
||||
RunLinear(input, directory.Path() / "captured.h5");
|
||||
|
||||
EXPECT_DOUBLE_EQ(state.Displacement()[8U], 5.0);
|
||||
EXPECT_EQ(SumTranslation(state.ExternalForce()),
|
||||
(std::array<double, 3>{0.0, 0.0, -4.0}));
|
||||
}
|
||||
|
||||
TEST(LinearShellSurfacePressure,
|
||||
AssemblesBeforeProjectionAndIncludesConstrainedReaction) {
|
||||
TempDirectory directory{"reaction"};
|
||||
const auto input = directory.Path() / "reaction.inp";
|
||||
WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));
|
||||
|
||||
const fesa::AnalysisState state =
|
||||
RunLinear(input, directory.Path() / "captured.h5");
|
||||
|
||||
EXPECT_EQ(SumTranslation(state.ExternalForce()),
|
||||
(std::array<double, 3>{0.0, 0.0, -4.0}));
|
||||
EXPECT_EQ(SumTranslation(state.Reaction()),
|
||||
(std::array<double, 3>{0.0, 0.0, 4.0}));
|
||||
}
|
||||
|
||||
TEST(LinearShellSurfacePressure,
|
||||
SatisfiesFreeResidualGlobalResultantAndMoment) {
|
||||
TempDirectory directory{"equilibrium"};
|
||||
const auto input = directory.Path() / "equilibrium.inp";
|
||||
WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));
|
||||
|
||||
const fesa::AnalysisState state =
|
||||
RunLinear(input, directory.Path() / "captured.h5");
|
||||
|
||||
for (const double value : state.Equilibrium()) {
|
||||
EXPECT_NEAR(value, 0.0, 1.0e-8);
|
||||
}
|
||||
EXPECT_NEAR(state.VerificationMetrics()[0U], 0.0, 1.0e-10);
|
||||
}
|
||||
|
||||
TEST(LinearShellSurfacePressure, PreservesS4S4rMeshAndCyclicOrderInvariance) {
|
||||
TempDirectory directory{"source-invariance"};
|
||||
const auto s4_input = directory.Path() / "s4.inp";
|
||||
const auto s4r_input = directory.Path() / "s4r.inp";
|
||||
const auto cyclic_input = directory.Path() / "cyclic.inp";
|
||||
WriteText(s4_input, ShellDeck("S4", "1, 2, 3, 4", false, true));
|
||||
WriteText(s4r_input, ShellDeck("S4R", "1, 2, 3, 4", false, true));
|
||||
WriteText(cyclic_input, ShellDeck("S4", "2, 3, 4, 1", false, true));
|
||||
|
||||
const fesa::AnalysisState s4 =
|
||||
RunLinear(s4_input, directory.Path() / "s4.h5");
|
||||
const fesa::AnalysisState s4r =
|
||||
RunLinear(s4r_input, directory.Path() / "s4r.h5");
|
||||
const fesa::AnalysisState cyclic =
|
||||
RunLinear(cyclic_input, directory.Path() / "cyclic.h5");
|
||||
|
||||
ASSERT_EQ(s4.ExternalForce().Size(), s4r.ExternalForce().Size());
|
||||
ASSERT_EQ(s4.ExternalForce().Size(), cyclic.ExternalForce().Size());
|
||||
for (std::size_t index = 0U; index < s4.ExternalForce().Size(); ++index) {
|
||||
EXPECT_DOUBLE_EQ(s4.ExternalForce()[index], s4r.ExternalForce()[index]);
|
||||
EXPECT_DOUBLE_EQ(s4.ExternalForce()[index], cyclic.ExternalForce()[index]);
|
||||
EXPECT_DOUBLE_EQ(s4.Reaction()[index], s4r.Reaction()[index]);
|
||||
EXPECT_DOUBLE_EQ(s4.Reaction()[index], cyclic.Reaction()[index]);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(LinearShellSurfacePressure, WritesSchemaZeroWithoutPressureDataset) {
|
||||
TempDirectory directory{"schema-zero"};
|
||||
const auto input = directory.Path() / "pressure.inp";
|
||||
const auto output = directory.Path() / "pressure_results.h5";
|
||||
WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));
|
||||
|
||||
EXPECT_EQ(fesa::FesaApplication{}.Run({input.string()}), 0);
|
||||
ASSERT_GT(H5Fis_hdf5(output.string().c_str()), 0);
|
||||
const hid_t file =
|
||||
H5Fopen(output.string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
|
||||
ASSERT_GE(file, 0);
|
||||
const hid_t metadata = H5Gopen2(file, "/metadata", H5P_DEFAULT);
|
||||
ASSERT_GE(metadata, 0);
|
||||
const hid_t schema = H5Aopen(metadata, "schema_version", H5P_DEFAULT);
|
||||
ASSERT_GE(schema, 0);
|
||||
std::uint64_t schema_version = 0U;
|
||||
ASSERT_GE(H5Aread(schema, H5T_NATIVE_UINT64, &schema_version), 0);
|
||||
EXPECT_EQ(schema_version, 0U);
|
||||
EXPECT_EQ(H5Lexists(file, "/steps/Step-1/frames/0/surface_pressure",
|
||||
H5P_DEFAULT),
|
||||
0);
|
||||
EXPECT_EQ(H5Lexists(file, "/pressure", H5P_DEFAULT), 0);
|
||||
EXPECT_GE(H5Aclose(schema), 0);
|
||||
EXPECT_GE(H5Gclose(metadata), 0);
|
||||
EXPECT_GE(H5Fclose(file), 0);
|
||||
}
|
||||
Reference in New Issue
Block a user