geomObjectsUtil.h

Go to the documentation of this file.

/*
* -------------------------------------------
* Copyright (c) 2021 - 2024 Prashant K. Jha
* -------------------------------------------
* PeriDEM https://github.com/prashjha/PeriDEM
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE)
*/
 
#pragma once
 
#include "geomObjects.h"
 
namespace util {
 
namespace geometry {
 
struct GeomData {
 
std::string d_geomName;
 
std::vector<double> d_geomParams;
 
std::shared_ptr<util::geometry::GeomObject> d_geom_p;
 
std::pair<std::vector<std::string>, std::vector<std::string>> d_geomComplexInfo;
 
GeomData() : d_geom_p(nullptr) {};
 
GeomData(const GeomData &z)
        : d_geomName(z.d_geomName),
          d_geomParams(z.d_geomParams),
          d_geom_p(z.d_geom_p),
          d_geomComplexInfo(z.d_geomComplexInfo) {};
 
void createNullGeomObject(std::string description = "") {
  d_geomName = "null";
  d_geomParams.resize(0);
  d_geom_p = std::make_shared<util::geometry::NullGeomObject>(
          description);
};
 
void copyGeometry(GeomData &z, size_t dim);
 
void copyGeometry(std::string &name,
                  std::vector<double> &params,
                  std::pair<std::vector<std::string>, std::vector<std::string>> &complexInfo,
                  std::shared_ptr<util::geometry::GeomObject> &geom,
                  size_t dim);
 
std::string printStr(int nt = 0, int lvl = 0) const {
 
  auto tabS = util::io::getTabS(nt);
  std::ostringstream oss;
  oss << tabS << "------- GeomData --------" << std::endl
      << std::endl;
  oss << tabS << "Type = " << d_geomName << std::endl;
  oss << tabS << "Parameters = ["
      << util::io::printStr<double>(d_geomParams, 0)
      << "]" << std::endl;
  if (!d_geomComplexInfo.first.empty()) {
    oss << tabS << "Vec type for complex geometry = ["
        << util::io::printStr(d_geomComplexInfo.first, 0)
        << "]" << std::endl;
 
    oss << tabS << "Vec flag for complex geometry = ["
        << util::io::printStr(d_geomComplexInfo.second, 0)
        << "]" << std::endl;
  }
  if (d_geom_p != nullptr)
    oss << d_geom_p->printStr(nt + 1, lvl);
 
  return oss.str();
}
 
void print(int nt = 0, int lvl = 0) const {
  std::cout << printStr(nt, lvl);
}
}; // struct GeomData
 
const std::vector<std::string> acceptable_geometries = {"circle",
                                                    "square",
                                                    "rectangle",
                                                    "hexagon",
                                                    "triangle",
                                                    "drum2d",
                                                    "sphere",
                                                    "cube",
                                                    "cuboid"};
 
inline const std::vector<std::string> &getAcceptableGeometries() {
return acceptable_geometries;
};
 
struct BoxPartition {
 
util::Point d_xc; // centroid of box
std::pair<util::Point, util::Point> d_box; // two corner points
double d_r; // radius of circle inscribing box
std::vector<size_t> d_nodes; // id of nodes in this box
 
BoxPartition() : d_xc(util::Point()),
                 d_box({util::Point(), util::Point()}),
                 d_r(0.) {}
 
bool isNear(const BoxPartition &box, const double &tol) const {
  auto dx = d_xc - box.d_xc;
  return dx.length() < d_r + box.d_r + tol;
}
 
bool isNear(const util::Point &x, const double &tol) const {
 
  if (util::isLess(x.d_x, d_box.first.d_x - tol) or
      util::isLess(x.d_y, d_box.first.d_y - tol) or
      util::isLess(x.d_z, d_box.first.d_z - tol) or
      util::isGreater(x.d_x, d_box.second.d_x + tol) or
      util::isGreater(x.d_y, d_box.second.d_y + tol) or
      util::isGreater(x.d_z, d_box.second.d_z + tol))
    return false;
 
  return true;
}
 
void addNode(const size_t &i) {
  for (const auto &j: d_nodes)
    if (j == i)
      return;
 
  d_nodes.push_back(i);
}
};
 
std::vector<size_t> getNumParamsRequired(std::string geom_type);
 
bool checkParamForGeometry(size_t n, std::string geom_type);
 
bool isNumberOfParamForGeometryValid(size_t n, std::string geom_type);
 
bool checkParamForComplexGeometry(size_t n, std::string geom_type,
                              std::vector<std::string> vec_type);
 
bool
isNumberOfParamForComplexGeometryValid(size_t n, std::string geom_type,
                                   std::vector<std::string> vec_type);
 
void createGeomObjectOld(const std::string &type,
                     const std::vector<double> &params,
                     const std::vector<std::string> &vec_type,
                     const std::vector<std::string> &vec_flag,
                     std::shared_ptr<util::geometry::GeomObject> &obj,
                     const size_t &dim,
                     bool perform_check = true);
 
void createGeomObject(const std::string &geom_type,
                  const std::vector<double> &params,
                  const std::vector<std::string> &vec_type,
                  const std::vector<std::string> &vec_flag,
                  std::shared_ptr<util::geometry::GeomObject> &obj,
                  const size_t &dim,
                  bool perform_check = true);
 
 
void createGeomObject(GeomData &geomData,
                  const size_t &dim,
                  bool perform_check = true);
 
} // namespace geometry
 
} // namespace util