feat(shell-surface-pressure-load): step 4 - integrate-linear-shell-pressure

tests/integration/app/shell_surface_pressure_application_test.cpp

@@ -0,0 +1,145 @@
+#include "fesa/app/fesa_application.h"
+
+#include <gtest/gtest.h>
+
+#include <atomic>
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <hdf5.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-app-" + 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 application 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 application input."};
+  }
+}
+
+std::vector<char> ReadBytes(const std::filesystem::path& path) {
+  std::ifstream stream{path, std::ios::binary};
+  return {std::istreambuf_iterator<char>{stream},
+          std::istreambuf_iterator<char>{}};
+}
+
+std::string ShellDeck(const bool with_pressure, const bool collapsed) {
+  const std::string third_node = collapsed ? "3, 1., 0., 0.\n"
+                                           : "3, 1., 1., 0.\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.
+)inp"} +
+         third_node + R"inp(4, 0., 1., 0.
+*Element, type=S4
+1, 1, 2, 3, 4
+*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=All, instance=Shell-1
+1, 2, 3, 4
+*End Assembly
+*Material, name=Steel
+*Elastic
+1000., 0.25
+*Boundary
+All, 1, 6
+*Step, name=Load, nlgeom=NO
+*Static
+0.1, 1., 0.01, 1.
+)inp" +
+         dsload + "*End Step\n";
+}
+
+}  // namespace
+
+TEST(ShellSurfacePressureApplication,
+     LinearFailurePreservesExistingFinalAndNoCandidate) {
+  TempDirectory directory{"preserve-final"};
+  const auto input = directory.Path() / "invalid-pressure.inp";
+  const auto output = directory.Path() / "invalid-pressure_results.h5";
+  WriteText(input, ShellDeck(true, true));
+  const std::vector<char> previous{'p', 'r', 'i', 'o', 'r'};
+  {
+    std::ofstream stream{output, std::ios::binary | std::ios::trunc};
+    stream.write(previous.data(),
+                 static_cast<std::streamsize>(previous.size()));
+  }
+
+  const int exit_code = fesa::FesaApplication{}.Run({input.string()});
+
+  EXPECT_NE(exit_code, 0);
+  EXPECT_EQ(ReadBytes(output), previous);
+}
+
+TEST(ShellSurfacePressureApplication,
+     InputWithoutPressureRetainsExistingLinearBehavior) {
+  TempDirectory directory{"no-pressure"};
+  const auto input = directory.Path() / "no-pressure.inp";
+  const auto output = directory.Path() / "no-pressure_results.h5";
+  WriteText(input, ShellDeck(false, false));
+
+  EXPECT_EQ(fesa::FesaApplication{}.Run({input.string()}), 0);
+  ASSERT_TRUE(std::filesystem::exists(output));
+  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);
+  EXPECT_GT(H5Lexists(file, "/steps/Step-1/frames/0/nodal/displacement",
+                       H5P_DEFAULT),
+            0);
+  EXPECT_EQ(H5Lexists(file, "/steps/Step-1/frames/0/surface_pressure",
+                       H5P_DEFAULT),
+            0);
+  EXPECT_GE(H5Fclose(file), 0);
+}