bcBaseDeck.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_BCBASEDECK_H
#define INP_BCBASEDECK_H
 
#include "deckField.h"
#include "geom/geomIncludes.h"
#include "util/json.h"
 
namespace inp {
 
  struct BCBaseDeck {
    std::string d_type;
 
    std::string d_selectionType;
 
    bool d_isRegionActive;
 
    geom::GeomData d_regionGeomData;
 
    std::vector<size_t> d_pList;
 
    std::vector<size_t> d_pNotList;
 
    std::string d_timeFnType;
 
    std::string d_spatialFnType;
 
    std::vector<size_t> d_direction;
 
    std::vector<double> d_timeFnParams;
 
    std::vector<double> d_spatialFnParams;
 
    bool d_isDisplacementZero;
 
    std::string d_icType;
 
    util::Point d_icVec;
 
    BCBaseDeck(const json &j = json({}), std::string type = "Force_BC") :
        d_type(type), d_isRegionActive(false), d_isDisplacementZero(false) {
      readFromJson(j, type);
    };
 
    BCBaseDeck(bool isRegionActive,
               geom::GeomData regionGeomData = geom::GeomData(),
               std::vector<size_t> pList = std::vector<size_t>(),
               std::vector<size_t> pNotList = std::vector<size_t>(),
               std::string timeFnType = "",
               std::vector<double> timeFnParams = std::vector<double>(),
               std::string spatialFnType = "",
               std::vector<double> spatialFnParams = std::vector<double>(),
               std::vector<size_t> direction = std::vector<size_t>(),
               bool isDisplacementZero = false)
        : d_isRegionActive(isRegionActive), d_regionGeomData(regionGeomData),
          d_pList(pList), d_pNotList(pNotList), d_timeFnType(timeFnType), d_timeFnParams(timeFnParams),
          d_spatialFnType(spatialFnType), d_spatialFnParams(spatialFnParams),
          d_direction(direction), d_isDisplacementZero(isDisplacementZero) {
 
      // fix selection type
      if (d_isRegionActive) {
        d_selectionType = "region";
        d_isRegionActive = true;
        if (d_pList.size() > 0)
          d_selectionType += "_with_include_list";
 
        if (d_pNotList.size() > 0)
          d_selectionType += "_with_exclude_list";
      } else {
        if (d_pList.size() > 0)
          d_selectionType = "particle";
      }
 
      if (d_isRegionActive) {
        // create a geometry object based on the data
        geom::createGeomObject(d_regionGeomData);
      }
    };
 
 
    static const std::vector<Field<BCBaseDeck>> &fields() {
      static const std::vector<Field<BCBaseDeck>> f = {
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_pList, "Particle_List", {},
              "Particles the condition applies to", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_pNotList, "Particle_Exclude_List", {},
              "Particles the condition does not apply to", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, std::vector<size_t>>(
              &BCBaseDeck::d_direction, "Direction", {},
              "Components the condition acts on, counted from one", {},
              [](const std::vector<size_t> &v) { return !v.empty(); }),
          field<BCBaseDeck, bool>(
              &BCBaseDeck::d_isDisplacementZero, "Zero_Displacement", false,
              "Hold the displacement at zero", {},
              [](const bool &v) { return v; }),
      };
      return f;
    }
 
    static const std::vector<Field<BCBaseDeck>> &timeFunctionFields() {
      static const std::vector<Field<BCBaseDeck>> f = {
          field(&BCBaseDeck::d_timeFnType, "Type", std::string(),
                "Time dependence of the condition"),
          field<BCBaseDeck, std::vector<double>>(
              &BCBaseDeck::d_timeFnParams, "Parameters", {},
              "Parameters of the time dependence", {},
              [](const std::vector<double> &v) { return !v.empty(); }),
      };
      return f;
    }
 
    static const std::vector<Field<BCBaseDeck>> &spatialFunctionFields() {
      static const std::vector<Field<BCBaseDeck>> f = {
          field(&BCBaseDeck::d_spatialFnType, "Type", std::string(),
                "Spatial dependence of the condition"),
          field<BCBaseDeck, std::vector<double>>(
              &BCBaseDeck::d_spatialFnParams, "Parameters", {},
              "Parameters of the spatial dependence", {},
              [](const std::vector<double> &v) { return !v.empty(); }),
      };
      return f;
    }
 
    static json getExampleJson(const json &given = json::object(),
                               const geom::GeomData *region = nullptr) {
      const std::vector<std::string> extra = {
          "Type", "Time_Function", "Spatial_Function", "IC_Type", "IC_Vector"};
      checkKeys(given, fields(), extra);
 
      const auto type = given.value("Type", std::string("Force_BC"));
 
      auto j = json({});
 
      if (region != nullptr) {
        auto j_geom = json({});
        geom::writeGeometry(j_geom, *region);
        // Must be an object: readFromJson does j.at("Region").at("Geometry").
        j["Region"] = json{{"Geometry", j_geom}};
      }
 
      json fieldsGiven =
          json{{"Particle_List",
                given.value("Particle_List", std::vector<size_t>())},
               {"Particle_Exclude_List",
                given.value("Particle_Exclude_List", std::vector<size_t>())}};
      if (type != "IC") {
        fieldsGiven["Direction"] =
            given.value("Direction", std::vector<size_t>());
        fieldsGiven["Zero_Displacement"] =
            given.value("Zero_Displacement", false);
      }
      j.update(applyGiven(fieldsGiven, fields()));
 
      if (given.find("Time_Function") != given.end())
        j["Time_Function"] =
            applyGiven(given.at("Time_Function"), timeFunctionFields());
 
      if (given.find("Spatial_Function") != given.end())
        j["Spatial_Function"] =
            applyGiven(given.at("Spatial_Function"), spatialFunctionFields());
 
      if (type == "IC") {
        const auto icType = given.value("IC_Type", std::string());
        if (icType == "Constant_Velocity")
          j[icType]["Velocity_Vector"] =
              given.value("IC_Vector", std::vector<double>());
      }
 
      return j;
    }
 
    static json getExampleJson(const std::string &) = delete;
    static json getExampleJson(const char *) = delete;
 
    void readFromJson(const json &j, std::string type) {
      if (j.empty())
        return;
 
      // fix selection type
      if (j.find("Region") != j.end()) {
        d_selectionType = "region";
        d_isRegionActive = true;
        if (j.find("Particle_List") != j.end())
          d_selectionType += "_with_include_list";
 
        if (j.find("Particle_Exclude_List") != j.end())
          d_selectionType += "_with_exclude_list";
      } else {
        d_isRegionActive = false;
        if (j.find("Particle_List") != j.end())
          d_selectionType = "particle";
      }
 
      if (d_isRegionActive) {
        geom::readGeometry(j.at("Region").at("Geometry"), d_regionGeomData);
        // create a geometry object based on the data
        geom::createGeomObject(d_regionGeomData);
      }
 
      readFields(*this, j, fields());
 
      if (j.find("Time_Function") != j.end())
        readFields(*this, j.at("Time_Function"), timeFunctionFields());
 
      if (j.find("Spatial_Function") != j.end())
        readFields(*this, j.at("Spatial_Function"), spatialFunctionFields());
 
      if (type != "IC" && j.find("Direction") == j.end())
        throw std::runtime_error(
            "Direction must be specified for boundary condition");
 
      // if it is initial condition
      if (type == "IC") {
        if (j.find("Constant_Velocity") != j.end()) {
          d_icType = "Constant_Velocity";
          d_icVec = util::Point(j.at("Constant_Velocity").value("Velocity_Vector", std::vector<double>({0., 0., 0.})));
        }
      }
    }
 
    std::string printStr(int nt = 0, int lvl = 0) const {
 
      auto tabS = util::io::getTabS(nt);
      std::ostringstream oss;
      oss << tabS << "------- BCBaseDeck --------" << std::endl << std::endl;
      oss << tabS << "Selection type  = " << d_selectionType << std::endl;
      oss << tabS << "Is region active  = " << d_isRegionActive << std::endl;
      if (d_regionGeomData.d_geom_p != nullptr) {
        oss << tabS << "Region geometry info: " << std::endl;
        oss << d_regionGeomData.printStr(nt + 1, lvl);
      }
      if (!d_pList.empty())
        oss << tabS << "Particle list = ["
            << util::io::printStr<size_t>(d_pList, 0) << "]" << std::endl;
      if (!d_pNotList.empty())
        oss << tabS << "Particle excluded list = ["
            << util::io::printStr<size_t>(d_pNotList, 0) << "]" << std::endl;
      oss << tabS << "Time function type = " << d_timeFnType << std::endl;
      oss << tabS << "Time function parameters = ["
          << util::io::printStr<double>(d_timeFnParams, 0) << "]" << std::endl;
      oss << tabS << "Spatial function type = " << d_spatialFnType << std::endl;
      oss << tabS << "Spatial function parameters = ["
          << util::io::printStr<double>(d_spatialFnParams, 0) << "]" << std::endl;
      oss << tabS << "Direction = [" << util::io::printStr<size_t>(d_direction, 0)
          << "]" << std::endl;
      oss << tabS << "Is displacement zero = " << d_isDisplacementZero << 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_BCBASEDECK_H