testDeck.h

Go to the documentation of this file.

/*
* -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef INP_TESTDECK_H
#define INP_TESTDECK_H
 
#include <string>
#include "deckField.h"
#include "util/io.h"
#include "util/json.h"
 
namespace inp {
  struct TestDeck {
    std::string d_testName;
 
    size_t d_particleIdCompressiveTest;
 
    size_t d_particleForceDirectionCompressiveTest;
 
 
    TestDeck(const json &j = json({}))
      : d_testName(""), d_particleIdCompressiveTest(0), d_particleForceDirectionCompressiveTest(0) {
      readFromJson(j);
    };
 
    TestDeck(std::string testName, size_t particleIdCompressiveTest = 0,
             size_t particleForceDirectionCompressiveTest = 0)
          : d_testName(testName),
          d_particleIdCompressiveTest(particleIdCompressiveTest),
          d_particleForceDirectionCompressiveTest(particleForceDirectionCompressiveTest) {};
 
    static const std::vector<Field<TestDeck>> &fields() {
      static const std::vector<Field<TestDeck>> f = {
          field(&TestDeck::d_testName, "Test_Name", std::string(),
                "Post-processing applied after the run"),
      };
      return f;
    }
 
    static bool isCompressive(const std::string &name) {
      return name == "Compressive_Test" || name == "compressive_test";
    }
 
    static json getExampleJson(const json &given = json::object()) {
      json j = applyGiven(given, fields(), {"Compressive_Test"});
      const auto name = j.at("Test_Name").get<std::string>();
      if (name.empty())
        return json({});
      if (isCompressive(name) && j.find("Compressive_Test") == j.end())
        j["Compressive_Test"] =
            json{{"Wall_Id", size_t(0)}, {"Wall_Force_Direction", size_t(0)}};
      return j;
    }
 
    static json getExampleJson(const std::string &) = delete;
    static json getExampleJson(const char *) = delete;
 
    void readFromJson(const json &j) {
      if (j.empty())
        return;
 
      readFields(*this, j, fields());
      if (isCompressive(d_testName)) {
        if (j.find("Compressive_Test") == j.end())
          throw std::runtime_error("Compressive test requires Compressive_Test section");
 
        d_particleIdCompressiveTest = j.at("Compressive_Test").value("Wall_Id", 0);
        d_particleForceDirectionCompressiveTest = j.at("Compressive_Test").value("Wall_Force_Direction", 0);
      }
    }
 
    std::string printStr(int nt = 0, int lvl = 0) const {
      auto tabS = util::io::getTabS(nt);
      std::ostringstream oss;
      oss << tabS << "------- TestDeck --------" << std::endl << std::endl;
      printFields(*this, oss, fields(), tabS);
      oss << tabS << "Particle id for compressive test = " << d_particleIdCompressiveTest << std::endl;
      oss << tabS << "Particle force direction for compressive test = " << d_particleForceDirectionCompressiveTest <<
          std::endl;
      oss << tabS << std::endl;
 
      return oss.str();
    }
 
    void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
  };
 
} // namespace inp
 
#endif //INP_TESTDECK_H