particleDeck.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_PARTICLEDECK_H
#define INP_PARTICLEDECK_H
 
#include "meshDeck.h"
#include "materialDeck.h"
#include "contactDeck.h"
#include "pNeighborDeck.h"
#include "pGenDeck.h"
#include "geom/geomIncludes.h"
#include "util/json.h"
#include <memory>
 
namespace inp {
 
struct ParticleDeck {
 
  std::string d_particleSimType;
 
  std::vector<geom::GeomData> d_pGeomVec;
 
  std::vector<inp::MeshDeck> d_pMeshVec;
 
  std::vector<inp::MaterialDeck> d_pMaterialVec;
 
  inp::ContactDeck d_contactDeck;
 
  inp::PNeighborDeck d_pNeighDeck;
 
  inp::PGenDeck d_pGenDeck;
 
  ParticleDeck(const json &j = json({}), std::string particleSimType = "Multi_Particle") {
    d_particleSimType = particleSimType;
    readFromJson(j);
  };
 
  void readFromJson(const json &j) {
 
    if (j.find("Particle") != j.end())
      readParticleGeomFromJson(j.at("Particle"));
 
    if (j.find("Mesh") != j.end())
      readParticleMeshFromJson(j.at("Mesh"));
 
    if (j.find("Material") != j.end())
      readParticleMaterialFromJson(j.at("Material"));
 
    if (j.find("Contact") != j.end())
      readParticleContactFromJson(j.at("Contact"));
 
    if (j.find("Neighbor") != j.end())
      readParticleNeighborFromJson(j.at("Neighbor"));
 
    if (j.find("Particle_Generation") != j.end())
      readParticleGenFromJson(j.at("Particle_Generation"));
 
    if (d_pGeomVec.size() != d_pMeshVec.size())
      throw std::runtime_error("Number of particle geometry groups must be equal to number of particle mesh groups");
  }
 
  static json getParticleGeomExampleJson(std::vector<geom::GeomData> pGeomVec = std::vector<geom::GeomData>()) {
 
    auto nSets = pGeomVec.size();
 
    if (nSets == 0)
      return json({});
 
    auto j = json({{"Sets", nSets}});
 
    for (size_t i = 0; i < nSets; i++) {
      auto js = json({});
      geom::writeGeometry(js, pGeomVec[i]);
      std::string set_name = "Set_" + std::to_string(i+1);
      j[set_name] = js;
    }
 
    return j;
  }
 
  void readParticleGeomFromJson(const json &j) {
 
    if (j.empty())
      return;
 
    if (d_particleSimType == "Multi_Particle") {
      auto nSets = j.value("Sets", size_t(0));
 
      d_pGeomVec.resize(nSets);
 
      for (size_t i = 0; i < nSets; i++) {
        auto set_name = "Set_" + std::to_string(i + 1);
        if (j.find(set_name) == j.end())
          throw std::runtime_error("Set " + set_name + " not found in particle geometry");
 
        auto js = j.at(set_name);
 
        // read
        geom::readGeometry(js, d_pGeomVec[i]);
        // create
        geom::createGeomObject(d_pGeomVec[i]);
      }
    } else if (d_particleSimType == "Single_Particle") {
      d_pGeomVec.resize(1);
      auto js = j.find("Set_1") == j.end()? j : j.at("Set_1");
      if (js.find("Type") != js.end()) {
        geom::readGeometry(js, d_pGeomVec[0]);
        geom::createGeomObject(d_pGeomVec[0]);
      }
    }
  }
 
  static json getParticleMeshExampleJson(std::vector<std::string> filenameVec = std::vector<std::string>(),
      std::vector<double> meshSizesVec = std::vector<double>()) {
 
    auto nSets = filenameVec.size();
 
    if (nSets == 0)
      return json({});
 
    auto j = json({{"Sets", nSets}});
    for (size_t i = 0; i < nSets; i++) {
      double h = meshSizesVec.size() > i ? meshSizesVec[i] : -1.;
      auto js = inp::MeshDeck::getExampleJson(
          json{{"File", filenameVec[i]}, {"Mesh_Size", h}});
 
      std::string set_name = "Set_" + std::to_string(i+1);
      j[set_name] = js;
    }
 
    return j;
  }
 
  void readParticleMeshFromJson(const json &j) {
    if (j.empty())
      return;
 
    if (d_particleSimType == "Multi_Particle") {
      auto nSets = j.value("Sets", size_t(0));
      d_pMeshVec.resize(nSets);
 
      for (size_t i = 0; i < nSets; i++) {
        auto set_name = "Set_" + std::to_string(i + 1);
 
        if (j.find(set_name) == j.end())
          throw std::runtime_error("Set " + set_name + " not found in particle mesh");
 
        auto js = j.at(set_name);
 
        // copy this set from a previous set?
        int copy_set = js.value("Copy_Data", int(-1));
        if (copy_set != -1) {
          std::string copy_set_tag = "Set_" + std::to_string(copy_set);
          auto js_copy = j.at(copy_set_tag);
          d_pMeshVec[i].readFromJson(js_copy);
        } else
          d_pMeshVec[i].readFromJson(js);
      }
    } else if (d_particleSimType == "Single_Particle") {
      d_pMeshVec.resize(1);
      auto js = j.find("Set_1") == j.end()? j : j.at("Set_1");
      d_pMeshVec[0].readFromJson(js);
    }
  }
 
  static json getParticleMaterialExampleJson(size_t nSets = 0) {
 
    if (nSets == 0)
      return json({});
 
    auto j = json({{"Sets", nSets}});
    for (size_t i = 0; i < nSets; i++) {
      std::string set_name = "Set_" + std::to_string(i+1);
      j[set_name] = {};
    }
 
    return j;
  }
 
  void readParticleMaterialFromJson(const json &j) {
    if (j.empty())
      return;
 
    if (d_particleSimType == "Multi_Particle") {
      auto nSets = j.value("Sets", size_t(0));
      d_pMaterialVec.resize(nSets);
 
      for (size_t i = 0; i < nSets; i++) {
        auto set_name = "Set_" + std::to_string(i + 1);
        if (j.find(set_name) == j.end())
          throw std::runtime_error("Set " + set_name + " not found in particle mesh");
 
        auto js = j.at(set_name);
 
        // copy this set from previous set?
        int copy_set = js.value("Copy_Data", int(-1));
        if (copy_set != -1) {
          std::string copy_set_tag = "Set_" + std::to_string(copy_set);
          auto js_copy = j.at(copy_set_tag);
          d_pMaterialVec[i].readFromJson(js_copy);
        } else {
          d_pMaterialVec[i].readFromJson(js);
        }
      } // loop over sets
    } else if (d_particleSimType == "Single_Particle") {
      d_pMaterialVec.resize(1);
      auto js = j.find("Set_1") == j.end()? j : j.at("Set_1");
      d_pMaterialVec[0].readFromJson(js);
    }
  }
 
  static json getParticleContactExampleJson(size_t nSets = 0) {
    return inp::ContactDeck::getExampleJson(json{{"Sets", nSets}});
  }
 
  void readParticleContactFromJson(const json &j) {
    d_contactDeck.readFromJson(j);
  }
 
  static json getParticleNeighborExampleJson(
      const json &given = json::object()) {
    return inp::PNeighborDeck::getExampleJson(given);
  }
 
  void readParticleNeighborFromJson(const json &j) {
    d_pNeighDeck.readFromJson(j);
  }
 
  static json getParticleGenExampleJson(const json &given = json::object()) {
    return inp::PGenDeck::getExampleJson(given);
  }
 
  void readParticleGenFromJson(const json &j) {
    d_pGenDeck.readFromJson(j);
  }
 
  std::string printStr(int nt = 0, int lvl = 0) const {
 
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- ParticleDeck --------" << std::endl << std::endl;
 
    oss << tabS << "Number of particle geometry groups  = " << d_pGeomVec.size() << std::endl;
    oss << tabS << "Number of particle mesh groups  = " << d_pMeshVec.size() << std::endl;
    oss << tabS << "Number of particle material groups  = " << d_pMaterialVec.size() << std::endl;
 
    oss << tabS << "Particle geometry data:" << std::endl;
    for (size_t i = 0; i < d_pGeomVec.size(); i++) {
      oss << tabS << "Particle geometry data for group = " << i << std::endl;
      oss << d_pGeomVec[i].printStr(nt + 1, lvl);
    }
 
 
    oss << tabS << "Particle mesh data:" << std::endl;
    for (size_t i = 0; i < d_pMeshVec.size(); i++) {
      oss << tabS << "Particle mesh data for group = " << i << std::endl;
      oss << d_pMeshVec[i].printStr(nt + 1, lvl);
    }
 
    oss << tabS << "Particle material data:" << std::endl;
    for (size_t i = 0; i < d_pMaterialVec.size(); i++) {
      oss << tabS << "Particle material data for group = " << i << std::endl;
      oss << d_pMaterialVec[i].printStr(nt + 1, lvl);
    }
 
    oss << tabS << "Contact data:" << std::endl;
    oss << d_contactDeck.printStr(nt + 1, lvl);
 
    oss << tabS << "Neighbor data:" << std::endl;
    oss << d_pNeighDeck.printStr(nt+1, lvl);
 
    oss << tabS << "Particle generation data:" << std::endl;
    oss << d_pGenDeck.printStr(nt+1, lvl);
 
    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_PARTICLEDECK_H