modelDeck.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_MODELDECK_H
#define INP_MODELDECK_H
 
#include <string>
#include <stdexcept>
#include "deckField.h"
#include "util/io.h"
#include "util/json.h"
 
namespace inp {
  struct ModelDeck {
    std::string d_simType;
 
    bool d_isRestartActive;
 
    std::string d_spatialDiscretization;
 
    std::string d_timeDiscretization;
 
    bool d_populateElementNodeConnectivity;
 
    size_t d_quadOrder;
 
    std::string d_particleSimType;
 
    std::string d_mpiStrategy;
 
    std::string d_bondBreak;
 
    std::vector<std::pair<size_t, double>> d_rigidParticles;
 
    std::string d_selfContact;
 
    std::string d_wallContact;
 
    size_t d_dim;
 
    double d_tFinal;
 
    double d_dt;
 
    size_t d_Nt;
 
    int d_seed;
 
    ModelDeck(const json &j = json({}))
        : d_dim(0), d_isRestartActive(false), d_populateElementNodeConnectivity(false),
          d_tFinal(0.), d_dt(0.), d_Nt(0),
          d_particleSimType(""), d_mpiStrategy("auto"),
          d_bondBreak("tension"), d_selfContact("broken_bond_kn"),
          d_wallContact("meshed"), d_seed(0), d_quadOrder(1) {
 
      readFromJson(j);
    };
 
    ModelDeck(size_t dim, double tFinal = 1.0, size_t Nt = 10,
              std::string spatialDiscretization = "finite_difference",
              std::string timeDiscretization = "central_difference",
              bool populateElementNodeConnectivity = true,
              size_t quadOrder = 2,
              std::string particleSimType = "Multi_Particle",
              int seed = 0)
        : d_dim(dim), d_isRestartActive(false),
          d_spatialDiscretization(spatialDiscretization),
          d_timeDiscretization(timeDiscretization),
          d_populateElementNodeConnectivity(populateElementNodeConnectivity),
          d_tFinal(tFinal), d_dt(0.), d_Nt(Nt),
          d_particleSimType(particleSimType), d_mpiStrategy("auto"),
          d_bondBreak("tension"), d_selfContact("broken_bond_kn"),
          d_wallContact("meshed"), d_seed(seed), d_quadOrder(quadOrder) {
 
      if (d_timeDiscretization == "central_difference" or d_timeDiscretization == "velocity_verlet")
        d_simType = "explicit";
 
      if (std::abs(d_tFinal) < 1.0E-10 or d_Nt <= 0) {
        throw std::runtime_error(
            util::io::Msg()
            << "Error: Check Final_Time and Time_Steps data.\n");
      }
 
      d_dt = d_tFinal / d_Nt;
    };
 
    static const std::vector<Field<ModelDeck>> &fields() {
      static const std::vector<Field<ModelDeck>> f = {
          field(&ModelDeck::d_dim, "Dimension", size_t(2),
                "Spatial dimension", {{size_t(1), size_t(2), size_t(3)}, {}, {}}),
          field(&ModelDeck::d_tFinal, "Final_Time", 1.0,
                "End of the integration window"),
          field(&ModelDeck::d_Nt, "Time_Steps", size_t(10),
                "Number of time steps", {{}, size_t(1), {}}),
          field(&ModelDeck::d_populateElementNodeConnectivity,
                "Populate_ElementNodeConnectivity", true,
                "Build the element to node map, which strain output needs"),
          field(&ModelDeck::d_quadOrder, "Quad_Approximation_Order", size_t(2),
                "Order of the quadrature rule"),
          field(&ModelDeck::d_particleSimType, "Particle_Sim_Type",
                std::string("Multi_Particle"), "One body or many",
                {{"Multi_Particle", "Single_Particle"}, {}, {}}),
          field(&ModelDeck::d_mpiStrategy, "MPI_Strategy", std::string("auto"),
                "What is distributed across ranks",
                {{"auto", "none", "particle", "dof"}, {}, {}}),
          field(&ModelDeck::d_bondBreak, "Bond_Break", std::string("tension"),
                "Criterion for breaking a bond",
                {{"tension", "absolute_stretch"}, {}, {}}),
          field(&ModelDeck::d_selfContact, "Self_Contact",
                std::string("broken_bond_kn"),
                "Contact across broken bonds inside one body",
                {{"broken_bond_kn", "reference_gap", "none"}, {}, {}}),
          field(&ModelDeck::d_wallContact, "Wall_Contact",
                std::string("meshed"), "How a wall is represented for contact",
                {{"meshed", "analytical_plane"}, {}, {}}),
          field(&ModelDeck::d_seed, "Seed", 0,
                "Seed of the random number generator"),
      };
      return f;
    }
 
    static json getExampleJson(const json &given = json::object()) {
      json j = applyGiven(given, fields(),
                          {"Discretization_Type", "Rigid_Particles"});
      if (j.find("Discretization_Type") == j.end())
        j["Discretization_Type"] = json{{"Spatial", "finite_difference"},
                                        {"Time", "central_difference"}};
      return j;
    }
 
    void readFromJson(const json &j) {
      if (j.empty())
        return;
 
      readFields(*this, j, fields());
 
      d_spatialDiscretization = j.at("Discretization_Type").at("Spatial");
      d_timeDiscretization = j.at("Discretization_Type").at("Time");
      if (d_timeDiscretization == "central_difference" or
          d_timeDiscretization == "velocity_verlet")
        d_simType = "explicit";
 
      d_rigidParticles.clear();
      if (j.find("Rigid_Particles") != j.end()) {
        for (const auto &r : j.at("Rigid_Particles")) {
          const double mass = r.value("Mass", -1.);
          if (!(mass > 0.)) {
            throw std::runtime_error(
                util::io::Msg()
                << "Error: Model.Rigid_Particles entries need Mass > 0.\n");
          }
          d_rigidParticles.emplace_back(r.at("Id").get<size_t>(), mass);
        }
      }
 
      if (std::abs(d_tFinal) < 1.0E-10 or d_Nt <= 0) {
        throw std::runtime_error(
            util::io::Msg()
            << "Error: Check Final_Time and Time_Steps data.\n");
      }
 
      d_dt = d_tFinal / d_Nt;
    }
 
    std::string printStr(int nt = 0, int lvl = 0) const {
      auto tabS = util::io::getTabS(nt);
      std::ostringstream oss;
      oss << tabS << "------- ModelDeck --------" << std::endl << std::endl;
      printFields(*this, oss, fields(), tabS);
      oss << tabS << "Discretization_Type.Spatial = " << d_spatialDiscretization
          << std::endl;
      oss << tabS << "Discretization_Type.Time = " << d_timeDiscretization
          << std::endl;
      oss << tabS << "Simulation type = " << d_simType << std::endl;
      oss << tabS << "Time step size = " << d_dt << std::endl;
      oss << tabS << "Restart active = " << d_isRestartActive << 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_MODELDECK_H