contactDeck.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_CONTACTDECK_H
#define INP_CONTACTDECK_H
 
#include "contactPairDeck.h"
#include "deckField.h"
#include "util/json.h"
 
namespace inp {
 
struct ContactDeck {
 
  std::vector<std::vector<ContactPairDeck>> d_data;
 
  std::string d_dampingLaw;
 
  std::string d_frictionLaw;
 
  bool d_correctVolume;
 
  ContactDeck(const json &j = json({}))
      : d_dampingLaw("com_and_node"), d_frictionLaw("coulomb_simple"),
        d_correctVolume(true) {
    readFromJson(j);
  };
 
  const ContactPairDeck &getContact(const size_t &i, const size_t &j) const {
    //return d_data[i < j ? i : j][i < j ? j : i];
    return d_data[i][j];
  }
 
  ContactPairDeck &getContact(const size_t &i, const size_t &j) {
    //return d_data[i < j ? i : j][i < j ? j : i];
    return d_data[i][j];
  }
 
  static const std::vector<Field<ContactDeck>> &fields() {
    static const std::vector<Field<ContactDeck>> f = {
        field(&ContactDeck::d_dampingLaw, "Damping_Law",
              std::string("com_and_node"), "Where contact damping is applied",
              {{"com_and_node", "com", "node", "off"}, {}, {}}),
        field(&ContactDeck::d_frictionLaw, "Friction_Law",
              std::string("coulomb_simple"), "Tangential contact law",
              {{"coulomb_simple", "stick_slip"}, {}, {}}),
        field(&ContactDeck::d_correctVolume, "Correct_Volume", true,
              "Scale the neighbor volume by the overlap with the contact "
              "sphere"),
    };
    return f;
  }
 
  static json getExampleJson(const json &given = json::object()) {
    json j = applyGiven(given, fields(), {"Sets"});
    const auto nSets = j.value("Sets", size_t(0));
    if (nSets == 0)
      return json({});
 
    for (size_t i = 0; i < nSets; i++)
      for (size_t k = i; k < nSets; k++)
        j["Set_" + std::to_string(i + 1) + "_" + std::to_string(k + 1)] = {};
 
    return j;
  }
 
  void readFromJson(const json &j) {
    if (j.empty())
      return;
 
    readFields(*this, j, fields());
 
    auto nSets = j.value("Sets", size_t(0));
    d_data.resize(nSets);
    for (size_t i=0; i<nSets; i++)
      d_data[i].resize(nSets);
 
    for (size_t i = 0; i < nSets; i++) {
      for (size_t k = i; k < nSets; k++) {
        std::string set_name = "Set_" + std::to_string(i+1) + "_" + std::to_string(k+1);
        //std::cout << "\n\n\n processing " << set_name << "\n\n\n" << std::flush;
 
        auto cd = inp::ContactPairDeck();
 
        if (j.find(set_name) == j.end())
          throw std::runtime_error("Set " + set_name + " not found in contact block.");
 
        auto js = j.at(set_name);
 
        // copy this set from previous set?
        std::vector<int> copy_set = js.value("Copy_Data", std::vector<int>({-1, -1}));
        //std::cout << "copy_data = " << copy_set[0] << ", " << copy_set[1] << "\n" << std::flush;
 
        // check
        if ((copy_set[0] != -1 and copy_set[1] == -1) or (copy_set[0] == -1 and copy_set[1] != -1) or (copy_set.size() != 2))
          throw std::runtime_error("The pair of set ids for copying is invalid in contact block.");
 
        if (copy_set[0] != -1) {
          std::string copy_set_tag = "Set_" + std::to_string(copy_set[0]) + "_" + std::to_string(copy_set[1]);
          auto js_copy = j.at(copy_set_tag);
          cd.readFromJson(js_copy);
        } else {
          cd.readFromJson(js);
        }
 
        d_data[i][k] = cd;
        if (i != k)
          d_data[k][i] = cd;
      }
    }
  }
 
  std::string printStr(int nt = 0, int lvl = 0) const {
 
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- ContactDeck --------" << std::endl << std::endl;
    printFields(*this, oss, fields(), tabS);
    for (size_t i =0; i<d_data.size(); i++) {
      for (size_t j = 0; j < d_data.size(); j++) {
        oss << tabS << "ContactPairData id = (" << i << "," << j << ") info:"
                  << std::endl;
        oss << getContact(i,j).printStr(nt+2, 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_CONTACTDECK_H