geomObjectsUtil.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)
*/
 
#pragma once
 
#include "geomObjects.h"
#include "util/io.h"
#include "util/point.h"
#include <nlohmann_json/json.hpp>
using json = nlohmann::ordered_json;
 
namespace geom {
 
struct GeomData {
 
std::string d_geomName;
 
std::vector<double> d_geomParams;
 
std::shared_ptr<geom::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<geom::NullGeomObject>(
          description);
};
 
void copyGeometry(GeomData &z);
 
void copyGeometry(std::string &name,
                  std::vector<double> &params,
                  std::pair<std::vector<std::string>, std::vector<std::string>> &complexInfo,
                  std::shared_ptr<geom::GeomObject> &geom);
 
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",
                                                    "ellipse",
                                                    "square",
                                                    "rectangle",
                                                    "hexagon",
                                                    "triangle",
                                                    "drum2d",
                                                    "sphere",
                                                    "ellipsoid",
                                                    "cube",
                                                    "cuboid",
                                                    "cylinder",
                                                    "circle_minus_circle",
                                                    "ellipse_minus_ellipse",
                                                    "sphere_minus_sphere",
                                                    "rectangle_minus_rectangle",
                                                    "cuboid_minus_cuboid",
                                                    "open_rect_channel_2d",
                                                    "open_cuboid_channel_3d",
                                                    "complex"};
 
 
 
inline const std::vector<std::string> &getAcceptableGeometries() {
return acceptable_geometries;
};
 
 
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<geom::GeomObject> &obj,
                     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<geom::GeomObject> &obj,
                  bool perform_check = true);
 
std::vector<double> exampleGeomParams(const std::string &geom_type,
                                      const util::Point &c = util::Point(0., 0., 0.),
                                      double s = 0.001);
 
std::shared_ptr<GeomObject> makeExampleGeomObject(const std::string &geom_type,
                                                  const util::Point &c = util::Point(0., 0., 0.),
                                                  double s = 0.001);
 
void createGeomObject(GeomData &geomData,
                  bool perform_check = true);
 
 
void readGeometry(const json &j, geom::GeomData &geomData);
 
void writeGeometry(json &j, const geom::GeomData &geomData);
 
GeomObject* createGeomDeepCopy(GeomObject* obj);
 
} // namespace geom