util::geometry Namespace Reference

Provides geometrical methods such as point inside rectangle. More...

Data Structures
class	AnnulusGeomObject
	Defines annulus rectangle. More...
struct	BoxPartition
	Defines simple rectangle domain. More...
class	Circle
	Defines circle. More...
class	ComplexGeomObject
	Defines complex geometrical object. More...
class	Cube
	Defines cube. More...
class	Cuboid
	Defines cuboid. More...
class	Cylinder
	Defines cylinder. More...
class	Drum2D
	Defines Drum2D. More...
class	Ellipse
	Defines ellipse. More...
struct	GeomData
	Input data for geometrical objects. More...
class	GeomObject
	Defines abstract geometrical domain. More...
class	Hexagon
	Defines Hexagon. More...
class	Line
	Defines Line. More...
class	NullGeomObject
	Defines null (empty) geom object. More...
class	Rectangle
	Defines Rectangle. More...
class	Sphere
	Defines sphere. More...
class	Square
	Defines Square. More...
class	Triangle
	Defines Triangle. More...

Functions
const std::vector< std::string > &	getAcceptableGeometries ()
	Returns list of acceptable geometries for PeriDEM simulation.
std::vector< size_t >	getNumParamsRequired (std::string geom_type)
	Get num params required for creation of object.
bool	checkParamForGeometry (size_t n, std::string geom_type)
	Check parameter data for validity.
bool	isNumberOfParamForGeometryValid (size_t n, std::string geom_type)
	Ascertain if number of parameters are correct for the given geometry.
bool	checkParamForComplexGeometry (size_t n, std::string geom_type, std::vector< std::string > vec_type)
	Check parameter data for validity.
bool	isNumberOfParamForComplexGeometryValid (size_t n, std::string geom_type, std::vector< std::string > vec_type)
	Ascertain if number of parameters are correct for the given geometry.
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)
	Create geometrical object from the given data.
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)

Variables
const std::vector< std::string >	acceptable_geometries
	List of acceptable geometries for particles in PeriDEM.

Detailed Description

Provides geometrical methods such as point inside rectangle.

Function Documentation

checkParamForComplexGeometry()

bool util::geometry::checkParamForComplexGeometry	(	size_t	n,
		std::string	geom_type,
		std::vector< std::string >	vec_type
	)

Check parameter data for validity.

Parameters

n	Number of parameters available
geom_type	Geometry type of object
vec_type	For complex objects, specify types of sub-objects

Returns

bool True if number of parameter is incorrect so require further checks

Definition at line 107 of file geomObjectsUitl.cpp.

                                                                                     {
 
      return !util::geometry::checkParamForComplexGeometry(n, geom_type, vec_type);
    }

References checkParamForComplexGeometry().

Referenced by checkParamForComplexGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

checkParamForGeometry()

bool util::geometry::checkParamForGeometry	(	size_t	n,
		std::string	geom_type
	)

Check parameter data for validity.

Parameters

n	Number of parameters available
geom_type	Geometry type of object

Returns

bool True if number of parameter is incorrect so require further checks

Definition at line 102 of file geomObjectsUitl.cpp.

                                                                     {
 
      return !util::geometry::isNumberOfParamForGeometryValid(n, geom_type);
    }

References isNumberOfParamForGeometryValid().

Here is the call graph for this function:

createGeomObject() [1/2]

void util::geometry::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
	)

Referenced by util::geometry::GeomData::copyGeometry(), util::geometry::GeomData::copyGeometry(), model::DEMModel::createGeometryAtSite(), createGeomObject(), createGeomObjectOld(), inp::Input::setParticleData(), inp::Input::setParticleDeck(), inp::Input::setZoneData(), inp::Input::setZoneMeshDeck(), and model::DEMModel::updateGeometryObjectsPostInit().

Here is the caller graph for this function:

createGeomObject() [2/2]

void util::geometry::createGeomObject	(	GeomData &	geomData,
		const size_t &	dim,
		bool	perform_check = true
	)

Definition at line 949 of file geomObjectsUitl.cpp.

                                                              {
 
      createGeomObject(geomData.d_geomName, geomData.d_geomParams,
                       geomData.d_geomComplexInfo.first,
                       geomData.d_geomComplexInfo.second,
                       geomData.d_geom_p, dim, perform_check);
    }

References createGeomObject(), util::geometry::GeomData::d_geom_p, util::geometry::GeomData::d_geomComplexInfo, util::geometry::GeomData::d_geomName, and util::geometry::GeomData::d_geomParams.

Here is the call graph for this function:

createGeomObjectOld()

void util::geometry::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
	)

Create geometrical object from the given data.

Parameters

type	Type of object
params	Vector of parameters
vec_type	Sub-types of complex object
vec_flag	Flags of sub-types of complex object
obj	Pointer to object to which new object will be associated
dim	Dimension
perform_check	Perform check for sufficient parameters

std::cout << "creating complex object\n";

Definition at line 116 of file geomObjectsUitl.cpp.

                                                              {
 
      // for any of the objects below, issue error if number of parameters not
      // sufficient regardless of perform_check value
      std::vector<std::string> no_default_obj = {"cylinder", "complex",
                                                 "rectangle_minus_rectangle",
                                                 "cuboid_minus_cuboid"};
 
      bool check_passed; // true means check passed
      if (type != "complex")
        check_passed = isNumberOfParamForGeometryValid(params.size(), type);
      else
        check_passed = isNumberOfParamForComplexGeometryValid(params.size(), type,
                                                    vec_type);
 
      std::ostringstream oss;
      if (!check_passed) {
        oss << "Error: Data maybe invalid. Can not create geometrical object: "
            << type << " with params: " << util::io::printStr(params)
            << ", vec type: " << util::io::printStr(vec_type)
            << ", vec flag: " << util::io::printStr(vec_flag) << std::endl;
      }
 
      // issue error
      if (!check_passed) {
        if (perform_check || util::methods::isTagInList(type, no_default_obj)) {
          std::cerr << oss.str();
          exit(1);
        }
      }
 
      // create object
      if (type == "circle") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Circle>(
                  params[0], util::Point(params[1], params[2], params[3]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() < 1) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 1
                      << " parameters for creating circle. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(EXIT_FAILURE);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Circle>(params[0],
                                                         util::Point());
        } // if else check_failed
      } // if circle
      else if (type == "ellipse") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Ellipse>(params[0], params[1],
                                                         util::Point());
        } // if else check_failed
        else {
          // if check is failed check if we can use other constructor
          if (params.size() < 2) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 2
                      << " parameters for creating ellipse. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(EXIT_FAILURE);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Ellipse>(params[0], params[1],
                                                         util::Point());
        } // if else check_failed
      } // if ellipse
      else if (type == "rectangle") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Rectangle>(
                  params[0], params[1],
                  util::Point(params[2], params[3], params[4]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() != 6 or params.size() != 5) {
            // if params are not adequate
            std::cerr << "Error: need either 5 or 6"
                      << " parameters for creating Rectangle. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(EXIT_FAILURE);
          }
 
          // reached here it means we have adequate parameters
          if (params.size() == 6)
            obj = std::make_shared<util::geometry::Rectangle>(
                  util::Point(params[0], params[1], params[2]),
                  util::Point(params[3], params[4], params[5]));
          else if (params.size() == 5)
            obj = std::make_shared<util::geometry::Rectangle>(
                    params[0], params[1],
                    util::Point(params[2], params[3], params[4]));
        } // if else check_failed
      } // if rectangle
      else if (type == "square") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Square>(
                  params[0],
                  util::Point(params[2], params[3], params[4]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() != 6) {
            // if params are not adequate
            std::cerr << "Error: need " << 6
                      << " parameters for creating Square. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(EXIT_FAILURE);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Square>(
                  util::Point(params[0], params[1], params[2]),
                  util::Point(params[3], params[4], params[5]));
        } // if else check_failed
      } // if square
      else if (type == "triangle") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Triangle>(
                  params[0], util::Point(params[1], params[2], params[3]),
                  util::Point(params[4], params[5], params[6]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() != 4) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 4
                      << " parameters for creating triangle. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(1);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Triangle>(
                  params[0], util::Point(params[1], params[2], params[3]));
        }// if else check_failed
      }// if triangle
      else if (type == "hexagon") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Hexagon>(
                  params[0], util::Point(params[1], params[2], params[3]),
                  util::Point(params[4], params[5], params[6]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() != 4) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 4
                      << " parameters for creating hexagon. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(1);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Hexagon>(
                  params[0], util::Point(params[1], params[2], params[3]));
        }// if else check_failed
      }// if hexagon
      else if (type == "drum2d") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Drum2D>(
                  params[0], params[1],
                  util::Point(params[2], params[3], params[4]),
                  util::Point(params[5], params[6], params[7]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() < 5) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 5
                      << " parameters for creating drum2d. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(1);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Drum2D>(
                  params[0], params[1],
                  util::Point(params[2], params[3], params[4]));
        }// if else check_failed
      }// if drum2d
      else if (type == "sphere") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Sphere>(
                  params[0], util::Point(params[1], params[2], params[3]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() < 1) {
            // if params are not adequate
            std::cerr << "Error: need at least " << 1
                      << " parameters for creating sphere. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(1);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Sphere>(params[0],
                                                         util::Point());
        }// if else check_failed
      }// if sphere
      else if (type == "cuboid") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Cuboid>(
                  params[0], params[1], params[2],
                  util::Point(params[3], params[4], params[5]));
        } else {
          std::cerr << "Error: need at least " << 6
                    << " parameters for creating cuboid. "
                       "Number of params provided = "
                    << params.size()
                    << ", params = "
                    << util::io::printStr(params) << " \n";
          exit(1);
        }// if else check_failed
      }// if cuboid
      else if (type == "cube") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Cube>(
                  params[0],
                  util::Point(params[2], params[3], params[4]));
        } else {
          // if check is failed check if we can use other constructor
          if (params.size() < 6) {
            // if params are not adequate
            std::cerr << "Error: need " << 6
                      << " parameters for creating Cube. "
                         "Number of params provided = "
                      << params.size()
                      << ", params = "
                      << util::io::printStr(params) << " \n";
            exit(EXIT_FAILURE);
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<util::geometry::Cube>(
                  util::Point(params[0], params[1], params[2]),
                  util::Point(params[3], params[4], params[5]));
        } // if else check_failed
      } // if cube
      else if (type == "cylinder") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<util::geometry::Cylinder>(
                  params[0], util::Point(params[1], params[2], params[3]),
                  util::Point(params[4], params[5], params[6]));
        } else {
          std::cerr << "Error: need at least " << 7
                    << " parameters for creating Cylinder. "
                       "Number of params provided = "
                    << params.size()
                    << ", params = "
                    << util::io::printStr(params) << " \n";
          exit(1);
        }// if else check_failed
      }// if cylinder
      else if (type == "rectangle_minus_rectangle") {
 
        if (check_passed) {
          // if check is passed
          auto rin = new util::geometry::Rectangle(
                  util::Point(params[0], params[1],
                              params[2]),
                  util::Point(params[3], params[4], params[5]));
          auto rout = new util::geometry::Rectangle(
                  util::Point(params[6], params[7],
                              params[8]),
                  util::Point(params[9], params[10],
                              params[11]));
 
          obj = std::make_shared<util::geometry::AnnulusGeomObject>
                  (rin, rout, 2);
        } else {
          std::cerr << "Error: need at least " << 12
                    << " parameters for creating rectangle_minus_rectangle. "
                       "Number of params provided = "
                    << params.size()
                    << ", params = "
                    << util::io::printStr(params) << " \n";
          exit(1);
        }// if else check_failed
      }// if rectangle_minus_rectangle
      else if (type == "cuboid_minus_cuboid") {
 
        if (check_passed) {
          // if check is passed
          auto rin = new util::geometry::Cuboid(
                  util::Point(params[0], params[1],
                              params[2]),
                  util::Point(params[3], params[4],
                              params[5]));
          auto rout = new util::geometry::Cuboid(
                  util::Point(params[6], params[7],
                              params[8]),
                  util::Point(params[9], params[10],
                              params[11]));
 
          obj = std::make_shared<util::geometry::AnnulusGeomObject>
                  (rin, rout, 3);
        } else {
          std::cerr << "Error: need at least " << 12
                    << " parameters for creating cuboid_minus_cuboid. "
                       "Number of params provided = "
                    << params.size()
                    << ", params = "
                    << util::io::printStr(params) << " \n";
          exit(1);
        }// if else check_failed
      }// if cuboid_minus_cuboid
      else if (type == "complex") {
 
        if (check_passed) {
          // if check is passed
          std::vector<std::shared_ptr<util::geometry::GeomObject>> vec_obj(
                  vec_type.size());
 
          size_t param_start = 0;
          for (size_t i = 0; i < vec_type.size(); i++) {
            auto geom_type = vec_type[i];
            auto geom_flag = vec_flag[i];
            auto num_params = getNumParamsRequired(geom_type)[0];
 
            // get slice of full param vector
            auto p1 = params.begin() + param_start;
            auto p2 = params.begin() + param_start + num_params;
            auto geom_param = std::vector<double>(p1, p2);
 
            // create geom object
            createGeomObject(geom_type, geom_param, std::vector<std::string>(),
                             std::vector<std::string>(), vec_obj[i], dim);
 
            param_start += num_params;
          }
 
          // create complex geom object
          obj = std::make_shared<util::geometry::ComplexGeomObject>(vec_obj,
                                                                    vec_flag,
                                                                    dim);
          //obj->print();
        } else {
          std::cerr << "Error: Not enough parameters for creating complex. "
                       "Number of params provided = "
                    << params.size()
                    << ", params = "
                    << util::io::printStr(params) << " \n";
          exit(1);
        }// if else check_failed
      }// if complex
    }

References createGeomObject(), getNumParamsRequired(), isNumberOfParamForComplexGeometryValid(), isNumberOfParamForGeometryValid(), util::methods::isTagInList(), and util::io::printStr().

Here is the call graph for this function:

getAcceptableGeometries()

const std::vector< std::string > & util::geometry::getAcceptableGeometries ( )

inline

Returns list of acceptable geometries for PeriDEM simulation.

Definition at line 141 of file geomObjectsUtil.h.

                                                             {
return acceptable_geometries;
};

References acceptable_geometries.

getNumParamsRequired()

std::vector< size_t > util::geometry::getNumParamsRequired

(

std::string

geom_type

)

Get num params required for creation of object.

Parameters

geom_type

Geometry type of object

Returns

n Number of parameters required

Definition at line 36 of file geomObjectsUitl.cpp.

                                                                            {
 
      if (geom_type == "line")
        return {1, 4, 6};
      else if (geom_type == "triangle")
        return {1, 4, 7};
      else if (geom_type == "square")
        return {1, 4, 6};
      else if (geom_type == "rectangle")
        return {2, 5, 6};
      else if (geom_type == "hexagon")
        return {1, 4, 7};
      else if (geom_type == "drum2d")
        return {2, 5, 8};
      else if (geom_type == "cube")
        return {1, 4, 6};
      else if (geom_type == "cuboid")
        return {3, 6};
      else if (geom_type == "circle")
        return {1, 4};
      else if (geom_type == "ellipse")
        return {2, 5};
      else if (geom_type == "sphere")
        return {1, 4};
      else if (geom_type == "cylinder")
        return {7, 8};
      else if (geom_type == "angled_rectangle")
        return {6};
      else if (geom_type == "angled_cuboid")
        return {6};
      else if (geom_type == "rectangle_minus_rectangle")
        return {12};
      else if (geom_type == "cuboid_minus_cuboid")
        return {12};
      else {
        std::cerr << "Error: Invalid geometry type: " << geom_type << std::endl;
        exit(1);
      }
    }

Referenced by createGeomObjectOld(), isNumberOfParamForComplexGeometryValid(), and isNumberOfParamForGeometryValid().

Here is the caller graph for this function:

isNumberOfParamForComplexGeometryValid()

bool util::geometry::isNumberOfParamForComplexGeometryValid	(	size_t	n,
		std::string	geom_type,
		std::vector< std::string >	vec_type
	)

Ascertain if number of parameters are correct for the given geometry.

Parameters

n	Number of parameters available
geom_type	Geometry type of object
vec_type	For complex objects, specify types of sub-objects

Returns

bool True if number of parameter is correct

Definition at line 82 of file geomObjectsUitl.cpp.

                                                                                               {
 
      int num_params = 0;
      for (const auto &s: vec_type) {
        // only consider the biggest parameter set from the list
        auto nps = getNumParamsRequired(s);
        if (nps.size() > 0)
          num_params += nps[nps.size() - 1];
        else {
          std::cerr << "Error: Geometry type = " << s
                    << " has zero number of parameters required. \n";
          exit(EXIT_FAILURE);
        }
      }
      return n == num_params;
    }

References getNumParamsRequired().

Referenced by createGeomObjectOld().

Here is the call graph for this function:

Here is the caller graph for this function:

isNumberOfParamForGeometryValid()

bool util::geometry::isNumberOfParamForGeometryValid	(	size_t	n,
		std::string	geom_type
	)

Ascertain if number of parameters are correct for the given geometry.

Parameters

n	Number of parameters available
geom_type	Geometry type of object

Returns

bool True if number of parameter is correct

Definition at line 77 of file geomObjectsUitl.cpp.

                                                                               {
 
      return util::methods::isInList(n, getNumParamsRequired(geom_type));
    }

References getNumParamsRequired(), and util::methods::isInList().

Referenced by checkParamForGeometry(), and createGeomObjectOld().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

acceptable_geometries

const std::vector<std::string> util::geometry::acceptable_geometries

Initial value:

= {"circle",
                                                    "square",
                                                    "rectangle",
                                                    "hexagon",
                                                    "triangle",
                                                    "drum2d",
                                                    "sphere",
                                                    "cube",
                                                    "cuboid",
                                                    "ellipse"}

List of acceptable geometries for particles in PeriDEM.

Definition at line 129 of file geomObjectsUtil.h.

                                                   {"circle",
                                                    "square",
                                                    "rectangle",
                                                    "hexagon",
                                                    "triangle",
                                                    "drum2d",
                                                    "sphere",
                                                    "cube",
                                                    "cuboid",
                                                    "ellipse"};

Referenced by model::DEMModel::createGeometryAtSite(), and getAcceptableGeometries().