geom Namespace Reference

Namespaces
namespace	anonymous_namespace{geomObjects.cpp}
namespace	anonymous_namespace{openCuboidChannel3D.cpp}
namespace	anonymous_namespace{openRectChannel2D.cpp}

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
	Filled ellipse in the plane z = center.d_z, semi-axes in the xy plane. More...
class	Ellipsoid
	Ellipsoid: center \(\mathbf c\), semi-axes \(r_1,r_2,r_3\) in a body frame rotated from world by axis–angle \((\hat{\mathbf a},\theta)\) (Rodrigues). Axis-aligned case: \(\theta=0\) (axis ignored). 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	OpenCuboidChannel3D
	Hollow axis-aligned cuboid shell with uniform wall thickness and one outer face open. More...
class	OpenRectChannel2D
	2D U-shaped cavity: thick rectangular frame with the top (+y) side open. More...
struct	ParticleTransform
	A struct that stores transformation parameters and provides method to transform the particle. Given a reference particle, this provides method to translate, rotate, and scale the reference particle. More...
class	Plane
	Infinite plane: free space is the half-space in the normal direction. More...
class	Rectangle
	Defines Rectangle. More...
class	Sphere
	Defines sphere. More...
class	Square
	Defines Square. More...
class	Triangle
	Defines Triangle. More...
struct	WallContactHit
	Result of a wall-contact query against a geom (analytical walls). More...

Functions
size_t	getGeomTypeToDim (std::string type)
	Returns list of acceptable geometries for PeriDEM simulation.
util::Point	mapSimilarity (const util::Point &x, const util::Point &pivotDefault, const util::Point &t, double scale, double angle, const util::Point &axis, const util::Point *rotationPoint)
std::vector< size_t >	getNumParamsRequired (std::string geom_type)
	Get num params required for creation of object.
bool	isNumberOfParamForGeometryValid (size_t n, std::string geom_type)
	Ascertain if number of parameters are correct for the given geometry.
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.
bool	checkParamForGeometry (size_t n, std::string geom_type)
	Check parameter data for validity.
bool	checkParamForComplexGeometry (size_t n, std::string geom_type, std::vector< std::string > vec_type)
	Check parameter data for validity.
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)
	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< geom::GeomObject > &obj, bool perform_check)
void	createGeomObject (GeomData &geomData, bool perform_check)
std::vector< double >	exampleGeomParams (const std::string &geom_type, const util::Point &c=util::Point(0., 0., 0.), double s=0.001)
	Canonical parameter vector for examples, mesh generation tests, and demos.
std::shared_ptr< GeomObject >	makeExampleGeomObject (const std::string &geom_type, const util::Point &c=util::Point(0., 0., 0.), double s=0.001)
	One-liner: createGeomObject(exampleGeomParams(...)). Prefer this over per-class static factories so annulus and composite types stay in one place.
void	writeGeometry (json &j, const geom::GeomData &geomData)
void	readGeometry (const json &j, geom::GeomData &geomData)
GeomObject *	createGeomDeepCopy (GeomObject *obj)
	Creates a deep copy of a geometric object.
const std::vector< std::string > &	getAcceptableGeometries ()
	Returns list of acceptable geometries for PeriDEM simulation.
std::vector< util::Point >	getCornerPoints (size_t dim, const std::pair< util::Point, util::Point > &box)
	Returns all corner points in the box.
std::vector< std::pair< util::Point, util::Point > >	getEdges (size_t dim, const std::pair< util::Point, util::Point > &box)
	Returns all corner points in the box.
util::Point	getCenter (size_t dim, const std::pair< util::Point, util::Point > &box)
	Returns center point.
double	inscribedRadiusInBox (size_t dim, const std::pair< util::Point, util::Point > &box)
	Computes the radius of biggest circle/sphere completely within the object.
double	circumscribedRadiusInBox (size_t dim, const std::pair< util::Point, util::Point > &box)
	Computes the radius of smallest circle/sphere which can have the box inside.
util::Point	getPointOnLine (const util::Point &p1, const util::Point &p2, const double &s)
	Returns point in line formed by points p1 and p2.
double	computeMeshSize (const std::vector< util::Point > &nodes)
	Computes minimum distance between any two nodes.
double	computeMeshSize (const std::vector< util::Point > &nodes, size_t start, size_t end)
	Computes minimum distance between any two nodes.
std::pair< util::Point, util::Point >	computeBBox (const std::vector< util::Point > &nodes)
	Computes bounding box for vector nodes.
double	computeInscribedRadius (const std::pair< util::Point, util::Point > &box)
	Computes maximum radius of circle/sphere within a given box.
std::pair< util::Point, util::Point >	toPointBox (const std::vector< double > &p1, const std::vector< double > &p2)
	Create box from two coordinate data.
double	triangleArea (const util::Point &x1, const util::Point &x2, const util::Point &x3)
	Compute area of triangle.
void	computeNonlocalNeighborhood (const std::vector< util::Point > &nodes, double horizon, std::vector< std::vector< size_t > > &nodeNeighs)
	Partitions the nodes based on node neighborlist supplied. Function first creates a graph with nodes as vertices and edges given by node neighbors. Then the metis function is called to partition the graph into specified number of parts.
void	ellipsoidRotationMatrix (const Ellipsoid &e, double R[9])
	Row-major 3×3 rotation \(\mathbf R\) from ellipsoid axis–angle (identity if \(\theta=0\)).
Methods to check intersection of geometric objects
bool	areBoxesNear (const std::pair< util::Point, util::Point > &b1, const std::pair< util::Point, util::Point > &b2, const double &tol, size_t dim)
	Checks if given two boxes are within given distance from each other.
bool	doLinesIntersect (const std::pair< util::Point, util::Point > &line_1, const std::pair< util::Point, util::Point > &line_2)
	Do lines intersect.
double	distanceBetweenLines (const std::pair< util::Point, util::Point > &line_1, const std::pair< util::Point, util::Point > &line_2)
	Compute distance between lines.
double	distanceBetweenSegments (const std::pair< util::Point, util::Point > &line_1, const std::pair< util::Point, util::Point > &line_2)
	Compute distance between lines.
double	distanceBetweenPlanes (const std::pair< util::Point, util::Point > &plane_1, const std::pair< util::Point, util::Point > &plane_2)
	Compute distance between planes.
double	pointDistanceLine (const util::Point &p, const std::pair< util::Point, util::Point > &line)
	Compute distance between point and line.
double	pointDistanceSegment (const util::Point &p, const std::pair< util::Point, util::Point > &line)
	Compute distance between point and line.
double	pointDistancePlane (const util::Point &p, const std::pair< util::Point, util::Point > &plane)
	Compute distance between point and plane.
Methods to check point in domain
bool	isPointInsideBox (util::Point x, size_t dim, const std::pair< util::Point, util::Point > &box)
	Returns true if point is inside box.
bool	isPointInsideRectangle (util::Point x, double x_min, double x_max, double y_min, double y_max)
	Checks if point is inside a rectangle.
bool	isPointInsideRectangle (util::Point x, util::Point x_lb, util::Point x_rt)
	Checks if point is inside a rectangle.
bool	isPointInsideAngledRectangle (util::Point x, double x_min, double x_max, double y_min, double y_max, double theta)
	Checks if point is inside an angled rectangle.
bool	isPointInsideCuboid (util::Point x, util::Point x_lbb, util::Point x_rtf)
	Checks if point is inside a cuboid.
bool	isPointInsideCylinder (const util::Point &p, const double &length, const double &radius, const util::Point &axis)
	Returns true if point is inside the cylinder.
bool	isPointInsideCylinder (const util::Point &p, const double &radius, const util::Point &x1, const util::Point &x2)
	Returns true if point is inside the cylinder.
bool	isPointInsideEllipse (const util::Point &p, const util::Point &center, const std::vector< double > &radius_vec, unsigned int dim)
	Returns true if point is inside the ellipsoid.
bool	isPointInsideEllipse (const util::Point &p, const util::Point &center, const std::vector< double > &radius_vec, unsigned int dim, double &d)
	Returns true if point is inside the ellipsoid.

Variables
const std::map< std::string, size_t >	geom_type_to_dim
	Geometry type to dimension map.
const std::vector< std::string >	acceptable_geometries
	List of acceptable geometries for particles in PeriDEM.

Function Documentation

areBoxesNear()

bool geom::areBoxesNear	(	const std::pair< util::Point, util::Point > &	b1,
		const std::pair< util::Point, util::Point > &	b2,
		const double &	tol,
		size_t	dim
	)

Checks if given two boxes are within given distance from each other.

Parameters

b1	Box 1
b2	Box 2
tol	Tolerance for checking
dim	Dimension of the objects

Returns

True If within given distance

Note

TODO This is not precise and can be improved.

Definition at line 124 of file geomUtilFunctions.cpp.

                              {
 
  auto cp1 = getCornerPoints(dim, b1);
  auto cp2 = getCornerPoints(dim, b2);
 
  for (auto p : cp1) {
 
    // check 1: If any of the corner points of box 1 are inside box 2
    if (isPointInsideBox(p, dim, b2))
      return true;
 
    // check 2: If any pair of corner points of box 1 and box 2 are at
    // distance smaller than the tolerance
    for (auto pp : cp2) {
      auto dx = pp - p;
      if (util::isLess(dx.length(), tol))
        return true;
    }
  }
 
  // check 3: Check if distance between centers of box 1 and box 2 are below
  // sum of tolerance, radius of circle inscribed in box 1, and radius of
  // circle inscribed in box 2
  auto dxc = getCenter(dim, b2) - getCenter(dim, b1);
  auto dist = tol + inscribedRadiusInBox(dim, b1) + inscribedRadiusInBox(dim,
      b2);
 
  if (util::isLess(dxc.length(), dist))
    return true;
 
  // check 4: Check if distance between centers of box 1 and box 2 are below
  // sum of tolerance, radius of circle inscribed in box 1, and radius of
  // circle circumscribed in box 2
  dist = tol + inscribedRadiusInBox(dim, b1) + circumscribedRadiusInBox(dim,
                                                                         b2);
  if (util::isLess(dxc.length(), dist))
    return true;
 
  dist = tol + circumscribedRadiusInBox(dim, b1) + inscribedRadiusInBox(dim,
                                                                        b2);
  if (util::isLess(dxc.length(), dist))
    return true;
 
  return false;
}

References circumscribedRadiusInBox(), getCenter(), getCornerPoints(), inscribedRadiusInBox(), util::isLess(), and isPointInsideBox().

Referenced by geom::Triangle::isNear(), geom::Square::isNear(), geom::Rectangle::isNear(), geom::Hexagon::isNear(), geom::Drum2D::isNear(), geom::Cube::isNear(), geom::Cuboid::isNear(), geom::Ellipsoid::isNear(), geom::Cylinder::isNear(), geom::OpenCuboidChannel3D::isNear(), and geom::OpenRectChannel2D::isNear().

Here is the call graph for this function:

Here is the caller graph for this function:

checkParamForComplexGeometry()

bool geom::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 134 of file geomObjectsUtil.cpp.

                                                                                     {
 
      return !isNumberOfParamForComplexGeometryValid(n, geom_type, vec_type);
    }

References isNumberOfParamForComplexGeometryValid().

Here is the call graph for this function:

checkParamForGeometry()

bool geom::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 129 of file geomObjectsUtil.cpp.

                                                         {
 
      return !isNumberOfParamForGeometryValid(n, geom_type);
    }

References isNumberOfParamForGeometryValid().

Here is the call graph for this function:

circumscribedRadiusInBox()

double geom::circumscribedRadiusInBox	(	size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Computes the radius of smallest circle/sphere which can have the box inside.

Parameters

dim	Dimension of the box
box	Pair of corner points of the box

Returns

Radius Radius of inscribed circle/sphere

Definition at line 225 of file geomUtilFunctions.cpp.

                                                                                      {
 
  auto xc = getCenter(dim, box);
  auto cp = getCornerPoints(dim, box);
 
  auto dx = cp[0] - xc;
  auto r = dx.length();
 
  if (dim == 1)
    return r;
  else {
    for (auto p : cp) {
      dx = p - xc;
      if (util::isGreater(dx.length(), r))
        r = dx.length();
    }
 
    return r;
  }
}

References getCenter(), getCornerPoints(), and util::isGreater().

Referenced by areBoxesNear(), geom::Circle::isNear(), geom::Ellipse::isNear(), and geom::Sphere::isNear().

Here is the call graph for this function:

Here is the caller graph for this function:

computeBBox()

std::pair< util::Point, util::Point > geom::computeBBox

(

const std::vector< util::Point > &

nodes

)

Computes bounding box for vector nodes.

Parameters

nodes

List of nodal coordinates

Returns

Box Pair of corner points of box

Definition at line 623 of file geomUtilFunctions.cpp.

                                                                             {
 
  auto p1 = util::Point();
  auto p2 = util::Point();
  for (const auto& x : nodes) {
    if (util::isLess(x.d_x, p1.d_x))
      p1.d_x = x.d_x;
    if (util::isLess(x.d_y, p1.d_y))
      p1.d_y = x.d_y;
    if (util::isLess(x.d_z, p1.d_z))
      p1.d_z = x.d_z;
    if (util::isLess(p2.d_x, x.d_x))
      p2.d_x = x.d_x;
    if (util::isLess(p2.d_y, x.d_y))
      p2.d_y = x.d_y;
    if (util::isLess(p2.d_z, x.d_z))
      p2.d_z = x.d_z;
  }
 
  return {p1, p2};
}

References util::isLess().

Here is the call graph for this function:

computeInscribedRadius()

double geom::computeInscribedRadius

(

const std::pair< util::Point, util::Point > &

box

)

Computes maximum radius of circle/sphere within a given box.

Parameters

box	Pair of corner points of box

Returns

Radius Radius of circle/sphere

Definition at line 645 of file geomUtilFunctions.cpp.

                                     {
 
  return 0.5 * (box.first - box.second).length();
}

computeMeshSize() [1/2]

double geom::computeMeshSize

(

const std::vector< util::Point > &

nodes

)

Computes minimum distance between any two nodes.

Parameters

nodes

List of nodal coordinates

Returns

h Minimum distance

Definition at line 568 of file geomUtilFunctions.cpp.

                                                          {
 
  double guess = 0.;
  if (nodes.size() < 2)
    return guess;
 
  guess = (nodes[0] - nodes[1]).length();
  for (size_t i = 0; i < nodes.size(); i++)
    for (size_t j = 0; j < nodes.size(); j++)
      if (i != j) {
        double val = nodes[i].dist(nodes[j]);
 
        if (util::isLess(val, 1.0E-12)) {
 
          std::cout << "Check nodes are too close = "
                    << util::io::printStr<util::Point>({nodes[i],
                                                         nodes[j]})
                    << "\n";
          std::cout << "Distance = " << val << ", guess = " << guess << "\n";
        }
        if (util::isLess(val, guess))
          guess = val;
      }
 
  return guess;
}

References util::isLess().

Referenced by particle::BaseParticle::BaseParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

computeMeshSize() [2/2]

double geom::computeMeshSize	(	const std::vector< util::Point > &	nodes,
		size_t	start,
		size_t	end
	)

Computes minimum distance between any two nodes.

This only considers the nodes between start and end

Parameters

nodes	List of nodal coordinates
start	Start index from where to start
end	End index

Returns

h Minimum distance

Definition at line 595 of file geomUtilFunctions.cpp.

                                                   {
 
  double guess = 0.;
  if (nodes.size() < 2 or (end - start) < 2)
    return guess;
 
  guess = (nodes[start] - nodes[start + 1]).length();
  for (size_t i = start; i < end; i++)
    for (size_t j = start; j < end; j++)
      if (i != j) {
        double val = nodes[i].dist(nodes[j]);
 
        if (util::isLess(val, 1.0E-12)) {
 
          std::cout << "Check nodes are too close = "
                    << util::io::printStr<util::Point>({nodes[i],
                                                         nodes[j]})
                    << "\n";
          std::cout << "Distance = " << val << ", guess = " << guess << "\n";
        }
        if (util::isLess(val, guess))
          guess = val;
      }
 
  return guess;
}

References util::isLess().

Here is the call graph for this function:

computeNonlocalNeighborhood()

void geom::computeNonlocalNeighborhood	(	const std::vector< util::Point > &	nodes,
		double	horizon,
		std::vector< std::vector< size_t > > &	nodeNeighs
	)

Partitions the nodes based on node neighborlist supplied. Function first creates a graph with nodes as vertices and edges given by node neighbors. Then the metis function is called to partition the graph into specified number of parts.

Parameters

nodes	Nodal coordinates
horizon	Nonlocal radius
nodeNeighs	Neighborlist of nodes

Definition at line 665 of file geomUtilFunctions.cpp.

                                                                                {
  nodeNeighs.resize(nodes.size());
 
  auto nsearch_p = std::make_unique<NSearch>(nodes);
  double set_tree_time = nsearch_p->updatePointCloud(nodes, true);
  set_tree_time += nsearch_p->setInputCloud();
  std::cout << std::format("Tree setup time (ms) = {}. \n", set_tree_time);
 
  for (size_t i=0; i<nodes.size(); i++) {
    std::vector<size_t> neighs;
    std::vector<double> sqr_dist;
    nodeNeighs[i].resize(0);
 
    if (nsearch_p->radiusSearch(nodes[i], horizon, neighs, sqr_dist) > 0) {
      for (std::size_t j = 0; j < neighs.size(); ++j)
        if (neighs[j] != i) {
          nodeNeighs[i].push_back(neighs[j]);
        }
    }
  }
}

Referenced by test::testGraphPartitioning(), and test::testMPI().

Here is the caller graph for this function:

createGeomDeepCopy()

GeomObject * geom::createGeomDeepCopy

(

GeomObject *

obj

)

Creates a deep copy of a geometric object.

Parameters

obj	Pointer to the object to copy

Returns

Pointer to the newly created copy

Definition at line 1429 of file geomObjectsUtil.cpp.

                                                  {
    if (!obj)
      return nullptr;
 
    const std::string &type = obj->d_name;
    if (type == "null")
      return new NullGeomObject(*dynamic_cast<const NullGeomObject *>(obj));
    if (type == "plane")
      return new Plane(*dynamic_cast<const Plane *>(obj));
    if (type == "line")
      return new Line(*dynamic_cast<const Line *>(obj));
    if (type == "triangle")
      return new Triangle(*dynamic_cast<const Triangle *>(obj));
    if (type == "square")
      return new Square(*dynamic_cast<const Square *>(obj));
    if (type == "rectangle")
      return new Rectangle(*dynamic_cast<const Rectangle *>(obj));
    if (type == "hexagon")
      return new Hexagon(*dynamic_cast<const Hexagon *>(obj));
    if (type == "drum2d")
      return new Drum2D(*dynamic_cast<const Drum2D *>(obj));
    if (type == "cube")
      return new Cube(*dynamic_cast<const Cube *>(obj));
    if (type == "cuboid")
      return new Cuboid(*dynamic_cast<const Cuboid *>(obj));
    if (type == "circle")
      return new Circle(*dynamic_cast<const Circle *>(obj));
    if (type == "sphere")
      return new Sphere(*dynamic_cast<const Sphere *>(obj));
    if (type == "cylinder")
      return new Cylinder(*dynamic_cast<const Cylinder *>(obj));
    if (type == "ellipse")
      return new Ellipse(*dynamic_cast<const Ellipse *>(obj));
    if (type == "ellipsoid")
      return new Ellipsoid(*dynamic_cast<const Ellipsoid *>(obj));
    if (type == "annulus_object")
      return new AnnulusGeomObject(*dynamic_cast<const AnnulusGeomObject *>(obj));
    if (type == "open_rect_channel_2d")
      return new OpenRectChannel2D(*dynamic_cast<const OpenRectChannel2D *>(obj));
    if (type == "open_cuboid_channel_3d")
      return new OpenCuboidChannel3D(*dynamic_cast<const OpenCuboidChannel3D *>(obj));
    if (type == "complex")
      return new ComplexGeomObject(*dynamic_cast<const ComplexGeomObject *>(obj));
 
    throw std::invalid_argument(
        util::io::Msg()
        << "Error: Unsupported object type '" << type << "' in createGeomDeepCopy\n");
  }

References geom::GeomObject::d_name.

Referenced by geom::AnnulusGeomObject::AnnulusGeomObject(), geom::ComplexGeomObject::ComplexGeomObject(), particle::createParticlesFromFile(), geom::AnnulusGeomObject::operator=(), and geom::ComplexGeomObject::operator=().

Here is the caller graph for this function:

createGeomObject() [1/2]

void geom::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
	)

Definition at line 688 of file geomObjectsUtil.cpp.

                                                              {
 
      std::vector<size_t> num_params_needed;
 
      if (geom_type == "line") {
 
        num_params_needed = {1, 4, 6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Line>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Line>(params[0],
                                                           util::Point(
                                                                   params[1],
                                                                   params[2],
                                                                   params[3]));
 
              return;
            } else if (n == 6) {
              obj = std::make_shared<geom::Line>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
 
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Line
      else if (geom_type == "plane") {
        if (params.size() == 6) {
          obj = std::make_shared<geom::Plane>(
              util::Point(params[0], params[1], params[2]),
              util::Point(params[3], params[4], params[5]));
          return;
        }
      }
      else if (geom_type == "triangle") {
 
        num_params_needed = {1, 4, 7, 9};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Triangle>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Triangle>(
                      params[0],
                      util::Point(params[1], params[2], params[3]));
 
              return;
            } else if (n == 7) {
              obj = std::make_shared<geom::Triangle>(
                      params[0],
                      util::Point(params[1],params[2],params[3]),
                      util::Point(params[4],params[5],params[6]));
 
              return;
            } else if (n == 9) {
              obj = std::make_shared<geom::Triangle>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]),
                      util::Point(params[6], params[7], params[8]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Triangle
      else if (geom_type == "square") {
 
        num_params_needed = {1, 4, 6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Square>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Square>(params[0],
                                                             util::Point(
                                                                     params[1],
                                                                     params[2],
                                                                     params[3]));
              return;
            } else if (n == 6) {
              obj = std::make_shared<geom::Square>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Square
      else if (geom_type == "rectangle") {
 
        num_params_needed = {2, 5, 6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 2) {
              obj = std::make_shared<geom::Rectangle>(params[0],
                                                                params[1]);
              return;
            } else if (n == 5) {
              obj = std::make_shared<geom::Rectangle>(
                      params[0], params[1],
                      util::Point(params[2], params[3], params[4]));
              return;
            } else if (n == 6) {
              obj = std::make_shared<geom::Rectangle>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Rectangle
      else if (geom_type == "hexagon") {
 
        num_params_needed = {1, 4, 7};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Hexagon>(params[0]);
              return;
            } else if (n == 4) {
              // r, cx, cy, cz — same layout as triangle/circle 4-param branches (not params[2..4]).
              obj = std::make_shared<geom::Hexagon>(
                      params[0], util::Point(params[1], params[2], params[3]));
              return;
            } else if (n == 7) {
              obj = std::make_shared<geom::Hexagon>(
                      params[0],
                      util::Point(params[1], params[2], params[3]),
                      util::Point(params[4], params[5], params[6]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Hexagon
      else if (geom_type == "drum2d") {
 
        num_params_needed = {2, 5, 8};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 2) {
              obj = std::make_shared<geom::Drum2D>(
                      params[0], params[1]);
              return;
            } else if (n == 5) {
              obj = std::make_shared<geom::Drum2D>(
                      params[0], params[1],
                      util::Point(params[2], params[3], params[4]));
              return;
            } else if (n == 8) {
              obj = std::make_shared<geom::Drum2D>(
                      params[0], params[1],
                      util::Point(params[2], params[3], params[4]),
                      util::Point(params[5], params[6], params[7]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Drum2D
      else if (geom_type == "cube") {
 
        num_params_needed = {1, 4, 6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Cube>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Cube>(
                      params[0],
                      util::Point(params[1], params[2], params[3]));
              return;
            } else if (n == 6) {
              obj = std::make_shared<geom::Cube>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Cube
      else if (geom_type == "cuboid") {
 
        num_params_needed = {3, 6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 3) {
              obj = std::make_shared<geom::Cuboid>(
                      params[0], params[1], params[2]);
              return;
            } else if (n == 6) {
              obj = std::make_shared<geom::Cuboid>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Cuboid
      else if (geom_type == "circle") {
 
        num_params_needed = {1, 4};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Circle>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Circle>(
                      params[0],
                      util::Point(params[1], params[2], params[3]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Circle
      else if (geom_type == "sphere") {
 
        num_params_needed = {1, 4};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 1) {
              obj = std::make_shared<geom::Sphere>(params[0]);
              return;
            } else if (n == 4) {
              obj = std::make_shared<geom::Sphere>(
                      params[0],
                      util::Point(params[1], params[2], params[3]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Sphere
      else if (geom_type == "ellipse") {
 
        num_params_needed = {6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 6) {
              obj = std::make_shared<geom::Ellipse>(
                      params[0], params[1], params[2],
                      util::Point(params[3], params[4], params[5]));
              return;
            }
          }
        }
      } // Ellipse
      else if (geom_type == "ellipsoid") {
 
        num_params_needed = {6, 10};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 6) {
              obj = std::make_shared<geom::Ellipsoid>(
                      params[0], params[1], params[2],
                      util::Point(params[3], params[4], params[5]));
              return;
            }
            if (n == 10) {
              obj = std::make_shared<geom::Ellipsoid>(
                      params[0], params[1], params[2], params[3],
                      util::Point(params[4], params[5], params[6]),
                      util::Point(params[7], params[8], params[9]));
              return;
            }
          }
        }
      } // Ellipsoid
      else if (geom_type == "cylinder") {
 
        num_params_needed = {7, 8};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 7) {
              // r, center begin, axis vector (no normalization as length of axis is length of cylinder)
              obj = std::make_shared<geom::Cylinder>(
                      params[0],
                      util::Point(params[1], params[2], params[3]),
                      util::Point(params[4], params[5], params[6]));
              return;
            } else if (n == 8) {
              // r, length, center begin, unit axis vector
              obj = std::make_shared<geom::Cylinder>(
                      params[0], params[1],
                      util::Point(params[2], params[3], params[4]),
                      util::Point(params[5], params[6], params[7]));
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // Cylinder
      else if (geom_type == "angled_rectangle") {
 
        num_params_needed = {6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 6) {
              obj = std::make_shared<geom::Rectangle>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
 
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // angled_rectangle
      else if (geom_type == "angled_cuboid") {
 
        num_params_needed = {6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 6) {
              obj = std::make_shared<geom::Cuboid>(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
 
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // angled_cuboid
      else if (geom_type == "rectangle_minus_rectangle") {
 
        num_params_needed = {12};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 12) {
 
              auto rin = new geom::Rectangle(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              auto rout = new geom::Rectangle(
                      util::Point(params[6], params[7], params[8]),
                      util::Point(params[9], params[10], params[11]));
 
              obj = std::make_shared<geom::AnnulusGeomObject>
                      (rin, rout);
 
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // rectangle_minus_rectangle
      else if (geom_type == "cuboid_minus_cuboid") {
 
        num_params_needed = {12};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 12) {
 
              auto rin = new geom::Cuboid(
                      util::Point(params[0], params[1], params[2]),
                      util::Point(params[3], params[4], params[5]));
              auto rout = new geom::Cuboid(
                      util::Point(params[6], params[7], params[8]),
                      util::Point(params[9], params[10], params[11]));
 
              obj = std::make_shared<geom::AnnulusGeomObject>
                      (rin, rout);
 
              return;
            }
          } // if params.size() == n
        } // loop over n
      } // cuboid_minus_cuboid
      else if (geom_type == "circle_minus_circle") {
 
        num_params_needed = {5};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 5) {
              const double cx = params[0];
              const double cy = params[1];
              const double cz = params[2];
              const double r_outer = params[3];
              const double r_inner = params[4];
              if (r_inner <= 0. || r_outer <= r_inner)
                throw std::runtime_error(
                        "circle_minus_circle: require 0 < r_inner < r_outer (cx,cy,cz,r_outer,r_inner).");
              auto *cin = new geom::Circle(r_inner, util::Point(cx, cy, cz));
              auto *cout = new geom::Circle(r_outer, util::Point(cx, cy, cz));
              obj = std::make_shared<geom::AnnulusGeomObject>(cin, cout);
              return;
            }
          }
        }
      } // circle_minus_circle
      else if (geom_type == "ellipse_minus_ellipse") {
 
        num_params_needed = {8};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 8) {
              const double a_out = params[0];
              const double b_out = params[1];
              const double a_in = params[2];
              const double b_in = params[3];
              const double theta = params[4];
              const util::Point c(params[5], params[6], params[7]);
              if (a_in <= 0. || b_in <= 0. || a_out <= a_in || b_out <= b_in)
                throw std::runtime_error(
                        "ellipse_minus_ellipse: require 0 < a_in < a_out and 0 < b_in < b_out.");
              auto *ein = new geom::Ellipse(a_in, b_in, theta, c);
              auto *eout = new geom::Ellipse(a_out, b_out, theta, c);
              obj = std::make_shared<geom::AnnulusGeomObject>(ein, eout);
              return;
            }
          }
        }
      } // ellipse_minus_ellipse
      else if (geom_type == "sphere_minus_sphere") {
 
        num_params_needed = {5};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 5) {
              const double cx = params[0];
              const double cy = params[1];
              const double cz = params[2];
              const double r_outer = params[3];
              const double r_inner = params[4];
              if (r_inner <= 0. || r_outer <= r_inner)
                throw std::runtime_error(
                        "sphere_minus_sphere: require 0 < r_inner < r_outer (cx,cy,cz,r_outer,r_inner).");
              auto *cin = new geom::Sphere(r_inner, util::Point(cx, cy, cz));
              auto *cout = new geom::Sphere(r_outer, util::Point(cx, cy, cz));
              obj = std::make_shared<geom::AnnulusGeomObject>(cin, cout);
              return;
            }
          }
        }
      } // sphere_minus_sphere
      else if (geom_type == "open_rect_channel_2d") {
 
        num_params_needed = {6};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 6) {
              obj = std::make_shared<geom::OpenRectChannel2D>(
                      params[0], params[1], params[2], params[3], params[4], params[5]);
              return;
            }
          }
        }
      } // open_rect_channel_2d
      else if (geom_type == "open_cuboid_channel_3d") {
 
        num_params_needed = {8};
 
        for (auto n: num_params_needed) {
          if (params.size() == n) {
            if (n == 8) {
              const int face = static_cast<int>(params[7]);
              if (face < 0 || face > 5)
                throw std::runtime_error(
                    "open_cuboid_channel_3d: open_face must be 0..5 (±x,±y,±z).");
              obj = std::make_shared<geom::OpenCuboidChannel3D>(
                      params[0], params[1], params[2], params[3], params[4], params[5], params[6],
                      face);
              return;
            }
          }
        }
      } // open_cuboid_channel_3d
      else if (geom_type == "complex") {
 
        /*
        std::cout << "vec_type = " << util::io::printStr(vec_type, 0)
                  << ", vec_flag = " << util::io::printStr(vec_flag, 0)
                  << "\n";
        */
 
        num_params_needed = {0};
        std::vector<size_t> params_level(vec_type.size());
        for (size_t i = 0; i < vec_type.size(); i++) {
 
          // only consider the biggest parameter set from the list
          auto nps = getNumParamsRequired(vec_type[i]);
          if (nps.size() > 0)
            params_level[i] = nps[nps.size() - 1];
          else {
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: Geometry type = " << vec_type[i]
                << " has zero number of parameters required. \n");
          }
 
          //std::cout << "Geom type = " << vec_type[i]
          //          << ", params required = " << params_level[i] << "\n";
 
          num_params_needed[0] += params_level[i];
        }
 
        std::vector<std::shared_ptr<geom::GeomObject>> objs(vec_type.size());
        std::vector<std::string> obj_flags(vec_type.size());
 
        if (params.size() == num_params_needed[0]) {
 
          // loop over objects and create
          size_t param_start = 0;
          for (size_t i = 0; i < vec_type.size(); i++) {
 
            auto geom_type_temp = vec_type[i];
            auto geom_flag_temp = vec_flag[i];
 
            std::vector<std::string> vec_type_temp;
            std::vector<std::string> vec_flag_temp;
 
            // find what range of parameters we need to provide
            std::vector<double> params_temp;
            for (size_t j=0; j<params_level[i]; j++)
              params_temp.push_back(params[j + param_start]);
 
            // call this function recursively
            obj_flags[i] = vec_flag[i];
            geom::createGeomObject(
                    geom_type_temp, params_temp, vec_type_temp, vec_flag_temp,
                    objs[i], perform_check);
 
            param_start += params_level[i];
          } // loop over objects
 
          // now create a composite object
          obj = std::make_shared<geom::ComplexGeomObject>(objs, obj_flags);
 
          return;
        } // if params.size() == n
      }  // complex
      else {
        throw std::invalid_argument(
            util::io::Msg()
            << "Error: Invalid geometry type: " << geom_type << std::endl);
      }
 
 
      throw std::invalid_argument(
          util::io::Msg()
          << printErrMsg(geom_type, params, num_params_needed));
    }

References createGeomObject(), and getNumParamsRequired().

Referenced by inp::BCBaseDeck::BCBaseDeck(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), anonymous_namespace{main.cpp}::buildInputJson(), geom::GeomData::copyGeometry(), geom::GeomData::copyGeometry(), createGeomObject(), createGeomObject(), createGeomObjectOld(), makeExampleGeomObject(), inp::BCBaseDeck::readFromJson(), inp::ParticleDeck::readParticleGeomFromJson(), and anonymous_namespace{testDeckRoundTrip.cpp}::testBCBaseDeck().

Here is the call graph for this function:

Here is the caller graph for this function:

createGeomObject() [2/2]

void geom::createGeomObject	(	GeomData &	geomData,
		bool	perform_check
	)

Definition at line 1258 of file geomObjectsUtil.cpp.

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

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

Here is the call graph for this function:

createGeomObjectOld()

void geom::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
	)

Create geometrical object from the given data.

Parameter ordering matches GeomData / getNumParamsRequired (see struct GeomData above).

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
perform_check	Perform check for sufficient parameters

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

Definition at line 143 of file geomObjectsUtil.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",
                                                 "circle_minus_circle",
                                                 "ellipse_minus_ellipse",
                                                 "sphere_minus_sphere",
                                                 "open_rect_channel_2d",
                                                 "open_cuboid_channel_3d"};
 
      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)) {
          throw std::invalid_argument(
              util::io::Msg()
              << oss.str());
        }
      }
 
      // create object
      if (type == "circle") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need at least " << 1
                << " parameters for creating circle. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::Circle>(params[0],
                                                         util::Point());
        } // if else check_failed
      } // if circle
      else if (type == "rectangle") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need either 5 or 6"
                << " parameters for creating Rectangle. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          if (params.size() == 6)
            obj = std::make_shared<geom::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<geom::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<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need " << 6
                << " parameters for creating Square. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::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<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need at least " << 4
                << " parameters for creating triangle. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::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<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need at least " << 4
                << " parameters for creating hexagon. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::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<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need at least " << 5
                << " parameters for creating drum2d. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::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<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need at least " << 1
                << " parameters for creating sphere. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::Sphere>(params[0],
                                                         util::Point());
        }// if else check_failed
      }// if sphere
      else if (type == "ellipse") {
 
        if (check_passed) {
          obj = std::make_shared<geom::Ellipse>(
                  params[0], params[1], params[2],
                  util::Point(params[3], params[4], params[5]));
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need at least " << 6
              << " parameters for creating ellipse (a, b, theta, cx, cy, cz). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // ellipse
      else if (type == "ellipsoid") {
 
        if (check_passed) {
          if (params.size() == 6) {
            obj = std::make_shared<geom::Ellipsoid>(
                    params[0], params[1], params[2], 
                    util::Point(params[4], params[5], params[6]));
          } else {
            obj = std::make_shared<geom::Ellipsoid>(
                    params[0], params[1], params[2], params[3],
                    util::Point(params[4], params[5], params[6]),
                    util::Point(params[7], params[8], params[9]));
          }
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need 6 parameters (cx, cy, cz, r1, r2, r3) or 10 parameters "
              "(cx, cy, cz, r1, r2, r3, ax, ay, az, theta) for creating ellipsoid. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // ellipsoid
      else if (type == "cuboid") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<geom::Cuboid>(
                  params[0], params[1], params[2],
                  util::Point(params[3], params[4], params[5]));
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need at least " << 6
              << " parameters for creating cuboid. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }// if else check_failed
      }// if cuboid
      else if (type == "cube") {
 
        if (check_passed) {
          // if check is passed
          obj = std::make_shared<geom::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
            throw std::invalid_argument(
                util::io::Msg()
                << "Error: need " << 6
                << " parameters for creating Cube. "
                "Number of params provided = "
                << params.size()
                << ", params = "
                << util::io::printStr(params) << " \n");
          }
 
          // reached here it means we have adequate parameters
          obj = std::make_shared<geom::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) {
          // Seven params: r, center of beginning cross-section, vector from beginning to end of cylinder
          obj = std::make_shared<geom::Cylinder>(
                  params[0], util::Point(params[1], params[2], params[3]),
                  util::Point(params[4], params[5], params[6]));
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need at least " << 7
              << " parameters for creating Cylinder. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }// if else check_failed
      }// if cylinder
      else if (type == "rectangle_minus_rectangle") {
 
        if (check_passed) {
          // if check is passed
          auto rin = new geom::Rectangle(
                  util::Point(params[0], params[1],
                              params[2]),
                  util::Point(params[3], params[4], params[5]));
          auto rout = new geom::Rectangle(
                  util::Point(params[6], params[7],
                              params[8]),
                  util::Point(params[9], params[10],
                              params[11]));
 
          obj = std::make_shared<geom::AnnulusGeomObject>
                  (rin, rout);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need at least " << 12
              << " parameters for creating rectangle_minus_rectangle. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }// if else check_failed
      }// if rectangle_minus_rectangle
      else if (type == "cuboid_minus_cuboid") {
 
        if (check_passed) {
          // if check is passed
          auto rin = new geom::Cuboid(
                  util::Point(params[0], params[1],
                              params[2]),
                  util::Point(params[3], params[4],
                              params[5]));
          auto rout = new geom::Cuboid(
                  util::Point(params[6], params[7],
                              params[8]),
                  util::Point(params[9], params[10],
                              params[11]));
 
          obj = std::make_shared<geom::AnnulusGeomObject>
                  (rin, rout);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need at least " << 12
              << " parameters for creating cuboid_minus_cuboid. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }// if else check_failed
      }// if cuboid_minus_cuboid
      else if (type == "circle_minus_circle") {
 
        if (check_passed) {
          const double cx = params[0];
          const double cy = params[1];
          const double cz = params[2];
          const double r_outer = params[3];
          const double r_inner = params[4];
          if (r_inner <= 0. || r_outer <= r_inner)
            throw std::runtime_error(
                    "circle_minus_circle: require 0 < r_inner < r_outer (params: cx,cy,cz,r_outer,r_inner).");
          auto *cin = new geom::Circle(r_inner, util::Point(cx, cy, cz));
          auto *cout = new geom::Circle(r_outer, util::Point(cx, cy, cz));
          obj = std::make_shared<geom::AnnulusGeomObject>(cin, cout);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need " << 5
              << " parameters for creating circle_minus_circle (cx, cy, cz, r_outer, r_inner). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // circle_minus_circle
      else if (type == "ellipse_minus_ellipse") {
 
        if (check_passed) {
          // a_out, b_out, a_in, b_in, theta, cx, cy, cz (concentric, same θ)
          const double a_out = params[0];
          const double b_out = params[1];
          const double a_in = params[2];
          const double b_in = params[3];
          const double theta = params[4];
          const util::Point c(params[5], params[6], params[7]);
          if (a_in <= 0. || b_in <= 0. || a_out <= a_in || b_out <= b_in)
            throw std::runtime_error(
                    "ellipse_minus_ellipse: require 0 < a_in < a_out and 0 < b_in < b_out.");
          auto *ein = new geom::Ellipse(a_in, b_in, theta, c);
          auto *eout = new geom::Ellipse(a_out, b_out, theta, c);
          obj = std::make_shared<geom::AnnulusGeomObject>(ein, eout);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need " << 8
              << " parameters for creating ellipse_minus_ellipse "
              "(a_out, b_out, a_in, b_in, theta, cx, cy, cz). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // ellipse_minus_ellipse
      else if (type == "sphere_minus_sphere") {
 
        if (check_passed) {
          const double cx = params[0];
          const double cy = params[1];
          const double cz = params[2];
          const double r_outer = params[3];
          const double r_inner = params[4];
          if (r_inner <= 0. || r_outer <= r_inner)
            throw std::runtime_error(
                    "sphere_minus_sphere: require 0 < r_inner < r_outer (params: cx,cy,cz,r_outer,r_inner).");
          auto *cin = new geom::Sphere(r_inner, util::Point(cx, cy, cz));
          auto *cout = new geom::Sphere(r_outer, util::Point(cx, cy, cz));
          obj = std::make_shared<geom::AnnulusGeomObject>(cin, cout);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need " << 5
              << " parameters for creating sphere_minus_sphere (cx, cy, cz, r_outer, r_inner). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // sphere_minus_sphere
      else if (type == "open_rect_channel_2d") {
 
        if (check_passed) {
          obj = std::make_shared<geom::OpenRectChannel2D>(
                  params[0], params[1], params[2], params[3], params[4], params[5]);
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need " << 6
              << " parameters for open_rect_channel_2d (x0,y0,x1,y1,t,z). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // open_rect_channel_2d
      else if (type == "open_cuboid_channel_3d") {
 
        if (check_passed) {
          obj = std::make_shared<geom::OpenCuboidChannel3D>(
                  params[0], params[1], params[2], params[3], params[4], params[5], params[6],
                  static_cast<int>(params[7]));
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: need " << 8
              << " parameters for open_cuboid_channel_3d "
              "(x0,y0,z0,x1,y1,z1,t,open_face 0..5). "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }
      } // open_cuboid_channel_3d
      else if (type == "complex") {
 
        if (check_passed) {
          // if check is passed
          std::vector<std::shared_ptr<geom::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]);
 
            param_start += num_params;
          }
 
          // create complex geom object
          obj = std::make_shared<geom::ComplexGeomObject>(vec_obj,
                                                                    vec_flag);
          //obj->print();
        } else {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: Not enough parameters for creating complex. "
              "Number of params provided = "
              << params.size()
              << ", params = "
              << util::io::printStr(params) << " \n");
        }// if else check_failed
      }// if complex
    }

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

Here is the call graph for this function:

distanceBetweenLines()

double geom::distanceBetweenLines	(	const std::pair< util::Point, util::Point > &	line_1,
		const std::pair< util::Point, util::Point > &	line_2
	)

Compute distance between lines.

Parameters

line_1	Line 1
line_2	Line 2

Returns

Value Distance

Definition at line 404 of file geomUtilFunctions.cpp.

                                         {
 
  // let line 1 is l1(s) = p + s u
  // and line 2 is l2(r) = q + r v
  // and let normal to the plane containing line 1 and 2 is
  // n = u x v / |u x v|
 
  auto u = line_1.second - line_1.first;
  auto v = line_2.second - line_2.first;
  auto w0 = line_1.first - line_2.first;
 
  double a = u * u;
  double b = u * v;
  double c = v * v;
  double d = u * w0;
  double e = v * w0;
 
  auto dp = w0 + ((b * e - c * d) * u + (a * e - b * d) * v) / (a * c - b * b);
 
  return dp.length();
}

distanceBetweenPlanes()

double geom::distanceBetweenPlanes	(	const std::pair< util::Point, util::Point > &	plane_1,
		const std::pair< util::Point, util::Point > &	plane_2
	)

Compute distance between planes.

Parameters

plane_1	Plane 1 given by pair of normal and one point which it contains
plane_2	Plane 2 given by pair of normal and one point which it contains

Returns

Value Distance

Definition at line 507 of file geomUtilFunctions.cpp.

                                           {
 
  // check if planes are parallel
  if (util::angle(plane_1.first, plane_2.first) < 1.0E-8)
    return 0.;
 
  return std::abs(plane_1.first * (plane_1.second - plane_2.second)) /
         plane_1.first.length();
}

References util::angle().

Here is the call graph for this function:

distanceBetweenSegments()

double geom::distanceBetweenSegments	(	const std::pair< util::Point, util::Point > &	line_1,
		const std::pair< util::Point, util::Point > &	line_2
	)

Compute distance between lines.

Parameters

line_1	Line 1
line_2	Line 2

Returns

Value Distance

Definition at line 429 of file geomUtilFunctions.cpp.

                                                                     {
 
  // let line 1 is l1(s) = p + s u
  // and line 2 is l2(r) = q + r v
  // and let normal to the plane containing line 1 and 2 is
  // n = u x v / |u x v|
 
  auto u = line_1.second - line_1.first;
  auto v = line_2.second - line_2.first;
  auto w0 = line_1.first - line_2.first;
 
  double a = u * u;
  double b = u * v;
  double c = v * v;
  double d = u * w0;
  double e = v * w0;
  double D = a * c - b * b;
  double sc, sN, sD = D;
  double tc, tN, tD = D;
 
  // compute line parameters of two closest points
  if (D < 1.0E-12) {
 
    sN = 0.;
    sD = 1.;
    tN = e;
    tD = c;
  } else {
 
    sN = b * e - c * d;
    tN = a * e - b * d;
 
    if (sN < 0.) {
      sN = 0.;
      tN = e;
      tD = c;
    } else if (sN > sD) {
      sN = sD;
      tN = e + b;
      tD = c;
    }
  }
 
  if (tN < 0.) {
 
    tN = 0.;
 
    if (-d < 0.)
      sN = 0.;
    else if (-d > a)
      sN = sD;
    else {
      sN = -d;
      sD = a;
    }
  } else if (tN > tD) {
 
    tN = tD;
 
    if (-d + b < 0.)
      sN = 0.;
    else if (-d + b > a)
      sN = sD;
    else {
      sN = -d + b;
      sD = a;
    }
  }
 
  sc = std::abs(sN) < 1.0E-12 ? 0. : sN / sD;
  tc = std::abs(tN) < 1.0E-12 ? 0. : tN / tD;
 
  auto dp = w0 + sc * u - tc * v;
 
  return dp.length();
}

doLinesIntersect()

bool geom::doLinesIntersect	(	const std::pair< util::Point, util::Point > &	line_1,
		const std::pair< util::Point, util::Point > &	line_2
	)

Do lines intersect.

Parameters

line_1	Line 1
line_2	Line 2

Returns

True If lines intersect, else false

Definition at line 373 of file geomUtilFunctions.cpp.

                                                                   {
 
  // change of variable so that first point of line_1 is at origin
  // After change of variables:
  // a is the second point of line_1
  // b is the first point of line_2
  // c is the difference of second and first point of line_2
  auto a = line_1.second - line_1.first;
  auto b = line_2.first - line_1.first;
  auto c = line_2.second - line_2.first;
 
  // check if the two lines are parallel
  if (util::angle(a / a.length(), c / c.length()) < 1.0E-8)
    return false;
 
  double a_dot_a = a.lengthSq();
  double a_dot_b = a * b;
  double a_dot_c = a * c;
  double b_dot_c = b * c;
  double c_dot_c = c.lengthSq();
 
  double r = (a_dot_a * b_dot_c - a_dot_b * a_dot_c) /
             (a_dot_c * a_dot_c - c_dot_c * a_dot_a);
 
  // if r is in (0,1) then this gives the intersection point
  // otherwise b + r c gives the point where two vectors originating from
  // a and originating from b would intersect
  return r > 0. and r < 1.;
}

References util::angle(), and util::Point::lengthSq().

Here is the call graph for this function:

ellipsoidRotationMatrix()

void geom::ellipsoidRotationMatrix	(	const Ellipsoid &	e,
		double	R[9]
	)

Row-major 3×3 rotation \(\mathbf R\) from ellipsoid axis–angle (identity if \(\theta=0\)).

Definition at line 689 of file geomUtilFunctions.cpp.

                                                              {
 
  if (std::abs(e.d_theta) < 1.0e-15) {
    R[0] = R[4] = R[8] = 1.;
    R[1] = R[2] = R[3] = R[5] = R[6] = R[7] = 0.;
    return;
  }
 
  const double kx = e.d_axis.d_x;
  const double ky = e.d_axis.d_y;
  const double kz = e.d_axis.d_z;
  const double c = std::cos(e.d_theta);
  const double s = std::sin(e.d_theta);
  const double t = 1.0 - c;
 
  R[0] = t * kx * kx + c;
  R[1] = t * kx * ky - kz * s;
  R[2] = t * kx * kz + ky * s;
  R[3] = t * kx * ky + kz * s;
  R[4] = t * ky * ky + c;
  R[5] = t * ky * kz - kx * s;
  R[6] = t * kx * kz - ky * s;
  R[7] = t * ky * kz + kx * s;
  R[8] = t * kz * kz + c;
}

References geom::Ellipsoid::d_axis, geom::Ellipsoid::d_theta, util::Point::d_x, util::Point::d_y, and util::Point::d_z.

Referenced by geom::Ellipsoid::box(), mesh_gen::buildEllipsoidOcc(), and geom::anonymous_namespace{geomObjects.cpp}::ellipsoidBodyCoords().

Here is the caller graph for this function:

exampleGeomParams()

std::vector< double > geom::exampleGeomParams	(	const std::string &	geom_type,
		const util::Point &	c = util::Point(0., 0., 0.),
		double	s = 0.001
	)

Canonical parameter vector for examples, mesh generation tests, and demos.

Convention matches twop_general_inbuilt: reference center c and length scale s (typical outer half-width). Names must be from getAcceptableGeometries().

Definition at line 1267 of file geomObjectsUtil.cpp.

                                                    {
      if (geom_type == "circle")
        return {s, c.d_x, c.d_y, c.d_z};
      if (geom_type == "plane")
        return {0., 1., 0., c.d_x, c.d_y, c.d_z};
      if (geom_type == "square")
        return {c.d_x - s, c.d_y - s, c.d_z, c.d_x + s, c.d_y + s, c.d_z};
      if (geom_type == "rectangle")
        return {c.d_x - 1.2 * s, c.d_y - 0.8 * s, c.d_z, c.d_x + 1.2 * s, c.d_y + 0.8 * s, c.d_z};
      if (geom_type == "triangle")
        return {s, c.d_x, c.d_y, c.d_z, 1.0, 0.0, 0.0};
      if (geom_type == "hexagon")
        return {s, c.d_x, c.d_y, c.d_z, 1.0, 0.0, 0.0};
      if (geom_type == "drum2d") {
        const double r = 1.2 * s;
        const double w = 0.35 * s;
        return {r, w, c.d_x, c.d_y, c.d_z, 1.0, 0.0, 0.0};
      }
      if (geom_type == "sphere")
        return {s, c.d_x, c.d_y, c.d_z};
      if (geom_type == "cube")
        return {2.0 * s, c.d_x, c.d_y, c.d_z};
      if (geom_type == "cuboid")
        return {c.d_x - s, c.d_y - 0.75 * s, c.d_z - 0.6 * s, c.d_x + s, c.d_y + 0.75 * s,
                c.d_z + 0.6 * s};
      if (geom_type == "cylinder")
        return {0.5 * s, c.d_x, c.d_y - s, c.d_z, 0., 2. * s, 0.};
      if (geom_type == "ellipse")
        return {1.2 * s, 0.85 * s, 0.25, c.d_x, c.d_y, c.d_z};
      if (geom_type == "ellipsoid")
        return {2. * s, 1. * s, 1.5 * s, c.d_x, c.d_y, c.d_z};
      if (geom_type == "circle_minus_circle")
        return {c.d_x, c.d_y, c.d_z, s, 0.35 * s};
      if (geom_type == "ellipse_minus_ellipse")
        return {1.2 * s, 0.85 * s, 0.7 * s, 0.5 * s, 0.25, c.d_x, c.d_y, c.d_z};
      if (geom_type == "sphere_minus_sphere")
        return {c.d_x, c.d_y, c.d_z, s, 0.35 * s};
      if (geom_type == "rectangle_minus_rectangle") {
        const double ri = 0.35 * s;
        const double lo_ix = c.d_x - ri, lo_iy = c.d_y - ri, lo_iz = c.d_z;
        const double hi_ix = c.d_x + ri, hi_iy = c.d_y + ri, hi_iz = c.d_z;
        const double lo_ox = c.d_x - s, lo_oy = c.d_y - s, lo_oz = c.d_z;
        const double hi_ox = c.d_x + s, hi_oy = c.d_y + s, hi_oz = c.d_z;
        return {lo_ix, lo_iy, lo_iz, hi_ix, hi_iy, hi_iz, lo_ox, lo_oy, lo_oz, hi_ox, hi_oy, hi_oz};
      }
      if (geom_type == "cuboid_minus_cuboid") {
        const double sx = s, sy = 0.75 * s, sz = 0.6 * s;
        const double f = 0.35;
        const double lo_ix = c.d_x - f * sx, lo_iy = c.d_y - f * sy, lo_iz = c.d_z - f * sz;
        const double hi_ix = c.d_x + f * sx, hi_iy = c.d_y + f * sy, hi_iz = c.d_z + f * sz;
        const double lo_ox = c.d_x - sx, lo_oy = c.d_y - sy, lo_oz = c.d_z - sz;
        const double hi_ox = c.d_x + sx, hi_oy = c.d_y + sy, hi_oz = c.d_z + sz;
        return {lo_ix, lo_iy, lo_iz, hi_ix, hi_iy, hi_iz, lo_ox, lo_oy, lo_oz, hi_ox, hi_oy, hi_oz};
      }
      if (geom_type == "open_rect_channel_2d") {
        const double wall_t = 0.35 * s;
        return {c.d_x - s, c.d_y - s, c.d_x + s, c.d_y + s, wall_t, c.d_z};
      }
      if (geom_type == "open_cuboid_channel_3d") {
        const double wall_t = 0.35 * s;
        const double open_face = 4.; // +z (matches 2D “open up”)
        return {c.d_x - s, c.d_y - s, c.d_z - s, c.d_x + s, c.d_y + s, c.d_z + s, wall_t, open_face};
      }
      throw std::runtime_error("exampleGeomParams: unknown geometry \"" + geom_type + "\"");
    }

References util::Point::d_x, util::Point::d_y, and util::Point::d_z.

Referenced by anonymous_namespace{main.cpp}::buildInputJson(), and makeExampleGeomObject().

Here is the caller graph for this function:

getAcceptableGeometries()

const std::vector< std::string > & geom::getAcceptableGeometries ( )

inline

Returns list of acceptable geometries for PeriDEM simulation.

Definition at line 151 of file geomObjectsUtil.h.

                                                             {
return acceptable_geometries;
};

References acceptable_geometries.

Referenced by mesh_gen::generateBuiltinParticleMeshGmsh(), anonymous_namespace{main.cpp}::isAcceptableGeometryName(), main(), and main().

Here is the caller graph for this function:

getCenter()

util::Point geom::getCenter	(	size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Returns center point.

Parameters

dim	Dimension of the box
box	Pair of points representing cuboid (rectangle in 2d)

Returns

Point Coordinates of center point

Definition at line 105 of file geomUtilFunctions.cpp.

                                                                 {
 
  if (dim == 1)
    return {0.5 * box.second.d_x + 0.5 * box.first.d_x, 0., 0.};
  else if (dim == 2)
    return {0.5 * box.second.d_x + 0.5 * box.first.d_x,
                        0.5 * box.second.d_y + 0.5 * box.first.d_y, 0.};
  else if (dim == 3)
    return {0.5 * box.second.d_x + 0.5 * box.first.d_x,
                        0.5 * box.second.d_y + 0.5 * box.first.d_y,
                        0.5 * box.second.d_z + 0.5 * box.first.d_z};
  else {
    throw std::invalid_argument(
        util::io::Msg()
        << "Error: Check dimension = " << dim << ".\n");
  }
}

References util::Point::d_x.

Referenced by areBoxesNear(), circumscribedRadiusInBox(), geom::Circle::isNear(), geom::Ellipse::isNear(), geom::Sphere::isNear(), and test::testUtilMethods().

Here is the caller graph for this function:

getCornerPoints()

std::vector< util::Point > geom::getCornerPoints	(	size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Returns all corner points in the box.

Parameters

dim	Dimension of the box
box	Pair of points representing cuboid (rectangle in 2d)

Returns

Vector Vector of corner points

Definition at line 26 of file geomUtilFunctions.cpp.

                                                          {
 
  if (dim == 1)
    return {box.first, box.second};
  else if (dim == 2)
    return {box.first,
            util::Point(box.second.d_x, box.first.d_y, 0.),
            box.second,
            util::Point(box.first.d_x, box.second.d_y, 0.)};
  else if (dim == 3) {
    double a = box.second.d_x - box.first.d_x;
    double b = box.second.d_y - box.first.d_y;
    double c = box.second.d_z - box.first.d_z;
    return {box.first,
            box.first + util::Point(a, 0., 0.),
            box.first + util::Point(a, b, 0.),
            box.first + util::Point(0., b, 0.),
            box.first + util::Point(0., 0., c),
            box.first + util::Point(a, 0., c),
            box.first + util::Point(a, b, c),
            box.first + util::Point(0., b, c)};
  }
  else {
    throw std::invalid_argument(
        util::io::Msg()
        << "Error: Check dimension = " << dim << ".\n");
  }
}

References util::Point::d_x.

Referenced by areBoxesNear(), circumscribedRadiusInBox(), geom::AnnulusGeomObject::doesIntersect(), geom::ComplexGeomObject::doesIntersect(), geom::Triangle::doesIntersect(), geom::Square::doesIntersect(), geom::Rectangle::doesIntersect(), geom::Hexagon::doesIntersect(), geom::Drum2D::doesIntersect(), geom::Cube::doesIntersect(), geom::Cuboid::doesIntersect(), geom::Circle::doesIntersect(), geom::Ellipse::doesIntersect(), geom::Sphere::doesIntersect(), geom::Ellipsoid::doesIntersect(), geom::Cylinder::doesIntersect(), geom::OpenCuboidChannel3D::doesIntersect(), geom::OpenRectChannel2D::doesIntersect(), getEdges(), geom::AnnulusGeomObject::isInside(), geom::ComplexGeomObject::isInside(), geom::Triangle::isInside(), geom::Square::isInside(), geom::Rectangle::isInside(), geom::Hexagon::isInside(), geom::Drum2D::isInside(), geom::Cube::isInside(), geom::Cuboid::isInside(), geom::Circle::isInside(), geom::Ellipse::isInside(), geom::Sphere::isInside(), geom::Ellipsoid::isInside(), geom::Cylinder::isInside(), geom::OpenCuboidChannel3D::isInside(), geom::OpenRectChannel2D::isInside(), geom::Circle::isNear(), geom::Ellipse::isNear(), geom::Sphere::isNear(), geom::AnnulusGeomObject::isOutside(), geom::ComplexGeomObject::isOutside(), geom::Triangle::isOutside(), geom::Square::isOutside(), geom::Rectangle::isOutside(), geom::Hexagon::isOutside(), geom::Drum2D::isOutside(), geom::Cube::isOutside(), geom::Cuboid::isOutside(), geom::Circle::isOutside(), geom::Ellipse::isOutside(), geom::Sphere::isOutside(), geom::Ellipsoid::isOutside(), geom::Cylinder::isOutside(), geom::OpenCuboidChannel3D::isOutside(), geom::OpenRectChannel2D::isOutside(), and test::testUtilMethods().

getEdges()

std::vector< std::pair< util::Point, util::Point > > geom::getEdges	(	size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Returns all corner points in the box.

Parameters

dim	Dimension of the box
box	Pair of points representing cuboid (rectangle in 2d)

Returns

Vector Vector of corner points

Definition at line 56 of file geomUtilFunctions.cpp.

                                    {
 
  std::vector<std::pair<util::Point, util::Point>> data;
  if (dim == 1) {
    data.emplace_back(box);
    return data;
  } else if (dim == 2) {
 
    // points returned by below function is in anti-clockwise order
    auto corner_pts = getCornerPoints(dim, box);
 
    data.emplace_back(corner_pts[0], corner_pts[1]);
    data.emplace_back(corner_pts[1], corner_pts[2]);
    data.emplace_back(corner_pts[2], corner_pts[3]);
    data.emplace_back(corner_pts[3], corner_pts[0]);
    return data;
  } else if (dim == 3) {
 
    // points returned by below function is in anti-clockwise order
    // first 4 points are on lower z-plane, and remaining are in upper z-plane
    auto corner_pts = getCornerPoints(dim, box);
 
    // edges in lower plane
    data.emplace_back(corner_pts[0], corner_pts[1]);
    data.emplace_back(corner_pts[1], corner_pts[2]);
    data.emplace_back(corner_pts[2], corner_pts[3]);
    data.emplace_back(corner_pts[3], corner_pts[0]);
 
    // edges in upper plane
    data.emplace_back(corner_pts[4], corner_pts[5]);
    data.emplace_back(corner_pts[5], corner_pts[6]);
    data.emplace_back(corner_pts[6], corner_pts[7]);
    data.emplace_back(corner_pts[7], corner_pts[4]);
 
    // edges parrallel to z-axis
    data.emplace_back(corner_pts[0], corner_pts[4]);
    data.emplace_back(corner_pts[1], corner_pts[5]);
    data.emplace_back(corner_pts[2], corner_pts[6]);
    data.emplace_back(corner_pts[3], corner_pts[7]);
 
    return data;
  } else {
    throw std::invalid_argument(
        util::io::Msg()
        << "getEdges(): Function implemented for dim = 1,2,3 only.\n");
  }
}

References getCornerPoints().

Referenced by test::testUtilMethods().

Here is the call graph for this function:

Here is the caller graph for this function:

getGeomTypeToDim()

size_t geom::getGeomTypeToDim ( std::string  type )

inline

Returns list of acceptable geometries for PeriDEM simulation.

Definition at line 47 of file geomObjects.h.

                                                 {
    return geom_type_to_dim.at(type);
  };

References geom_type_to_dim.

Referenced by geom::AnnulusGeomObject::AnnulusGeomObject(), geom::ComplexGeomObject::ComplexGeomObject(), and anonymous_namespace{testMeshGen.cpp}::meshDimForBuiltin().

Here is the caller graph for this function:

getNumParamsRequired()

std::vector< size_t > geom::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 47 of file geomObjectsUtil.cpp.

                                                                {
 
      if (geom_type == "line")
        return {1, 4, 6};
      else if (geom_type == "plane")
        return {6};
      else if (geom_type == "triangle")
        return {1, 4, 7, 9};
      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 == "sphere")
        return {1, 4};
      else if (geom_type == "ellipse")
        return {6};
      else if (geom_type == "ellipsoid")
        return {6, 10};
      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 if (geom_type == "circle_minus_circle")
        return {5};
      else if (geom_type == "ellipse_minus_ellipse")
        return {8};
      else if (geom_type == "sphere_minus_sphere")
        return {5};
      else if (geom_type == "open_rect_channel_2d")
        return {6};
      else if (geom_type == "open_cuboid_channel_3d")
        return {8};
      else {
        throw std::invalid_argument(
            util::io::Msg()
            << "Error: Invalid geometry type: " << geom_type << std::endl);
      }
    }

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

Here is the caller graph for this function:

getPointOnLine()

util::Point geom::getPointOnLine	(	const util::Point &	p1,
		const util::Point &	p2,
		const double &	s
	)

Returns point in line formed by points p1 and p2.

Parameters

p1	Point 1
p2	Point 2
s	Parametric coordinate

Returns

p Point

Definition at line 367 of file geomUtilFunctions.cpp.

                     {
  return (1. - s) * p1 + s * p2;
}

inscribedRadiusInBox()

double geom::inscribedRadiusInBox	(	size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Computes the radius of biggest circle/sphere completely within the object.

Parameters

dim	Dimension of the box
box	Pair of corner points of the box

Returns

Radius Radius of inscribed circle/sphere

Definition at line 199 of file geomUtilFunctions.cpp.

                                                                                      {
 
  double r = 0.5 * std::abs(box.second.d_x - box.first.d_x);
  if (dim == 1)
    return r;
  else if (dim == 2) {
    if (util::isGreater(r, 0.5 * std::abs(box.second.d_y - box.first.d_y)))
      return 0.5 * std::abs(box.second.d_y - box.first.d_y);
    else
      return r;
  } else if (dim == 3) {
    if (util::isGreater(r, 0.5 * std::abs(box.second.d_y - box.first.d_y)))
      r = 0.5 * std::abs(box.second.d_y - box.first.d_y);
 
    if (util::isGreater(r, 0.5 * std::abs(box.second.d_z - box.first.d_z)))
      return 0.5 * std::abs(box.second.d_z - box.first.d_z);
    else
      return r;
  } else {
    throw std::invalid_argument(
        util::io::Msg()
        << "inscribedRadiusInBox(): Function implemented for dim = 1,2,3 only.\n");
  }
}

References util::isGreater().

Referenced by areBoxesNear(), geom::Circle::isNear(), geom::Ellipse::isNear(), and geom::Sphere::isNear().

Here is the call graph for this function:

Here is the caller graph for this function:

isNumberOfParamForComplexGeometryValid()

bool geom::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 108 of file geomObjectsUtil.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 {
          throw std::invalid_argument(
              util::io::Msg()
              << "Error: Geometry type = " << s
              << " has zero number of parameters required. \n");
        }
      }
      return n == num_params;
    }

References getNumParamsRequired().

Referenced by checkParamForComplexGeometry(), and createGeomObjectOld().

Here is the call graph for this function:

Here is the caller graph for this function:

isNumberOfParamForGeometryValid()

bool geom::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 103 of file geomObjectsUtil.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:

isPointInsideAngledRectangle()

bool geom::isPointInsideAngledRectangle	(	util::Point	x,
		double	x_min,
		double	x_max,
		double	y_min,
		double	y_max,
		double	theta
	)

Checks if point is inside an angled rectangle.

Parameters

x	Point
x_min	X coordinate of left-bottom corner point
x_max	X coordinate of right-top corner point
y_min	Y coordinate of left-bottom corner point
y_max	Y coordinate of right-top corner point
theta	Angle of orientation of rectangle from x-axis

Returns

bool True if point inside rectangle, else false

Definition at line 266 of file geomUtilFunctions.cpp.

                                                                           {
  // we assume that the rectangle has passed the test
 
  //
  //                             (x2,y2)
  //                            o
  //
  //
  //
  //
  //
  //        o
  //      (x1,y1)
 
  // get divisors
  util::Point lam = util::rotateCW2D(
      util::Point(x2 - x1, y2 - y1, 0.0), theta);
 
  // double lam1 = (x2-x1) * std::cos(theta) + (y2-y1) * std::sin(theta);
  // double lam2 = -(x2-x1) * std::sin(theta) + (y2-y1) * std::cos(theta);
 
  // get mapped coordinate of x
  util::Point xmap = util::rotateCW2D(
      util::Point(x[0] - x1, x[1] - y1, 0.0), theta);
 
  // double xmap = (x[0]-x1) * std::cos(theta) + (x[1]-y1) * std::sin(theta);
  // double ymap = -(x[0]-x1) * std::sin(theta) + (x[1]-y1) * std::cos(theta);
 
  // check if mapped coordinate are out of range [0, lam1] and [0, lam2]
  return !(util::isLess(xmap[0], -1.0E-12) or
           util::isLess(xmap[1], -1.0E-12) or
           util::isGreater(xmap[0], lam[0] + 1.0E-12) or
           util::isGreater(xmap[1], lam[1] + 1.0E-12));
}

References util::isGreater(), util::isLess(), and util::rotateCW2D().

Here is the call graph for this function:

isPointInsideBox()

bool geom::isPointInsideBox	(	util::Point	x,
		size_t	dim,
		const std::pair< util::Point, util::Point > &	box
	)

Returns true if point is inside box.

Parameters

x	Point
dim	Dimension of the box
box	Pair of points representing cuboid (rectangle in 2d)

Returns

True If point is inside box

Definition at line 174 of file geomUtilFunctions.cpp.

                                                                {
 
  if (dim == 1)
    return !(util::isLess(x.d_x, box.first.d_x - 1.0E-12) or
             util::isGreater(x.d_x, box.second.d_x + 1.0E-12));
  else if (dim == 2)
    return !(util::isLess(x.d_x, box.first.d_x - 1.0E-12) or
             util::isLess(x.d_y, box.first.d_y - 1.0E-12) or
             util::isGreater(x.d_x, box.second.d_x + 1.0E-12) or
             util::isGreater(x.d_y, box.second.d_y + 1.0E-12));
  else if (dim == 3)
    return !(util::isLess(x.d_x, box.first.d_x - 1.0E-12) or
             util::isLess(x.d_y, box.first.d_y - 1.0E-12) or
             util::isLess(x.d_z, box.first.d_z - 1.0E-12) or
             util::isGreater(x.d_x, box.second.d_x + 1.0E-12) or
             util::isGreater(x.d_y, box.second.d_y + 1.0E-12) or
             util::isGreater(x.d_z, box.second.d_z + 1.0E-12));
  else {
    throw std::invalid_argument(
        util::io::Msg()
        << "isPointInsideBox(): Function implemented for dim = 1,2,3 only.\n");
  }
}

References util::Point::d_x, util::Point::d_y, util::Point::d_z, util::isGreater(), and util::isLess().

Referenced by areBoxesNear(), geom::Triangle::isNear(), geom::Square::isNear(), geom::Rectangle::isNear(), geom::Hexagon::isNear(), geom::Drum2D::isNear(), geom::Cube::isNear(), geom::Cuboid::isNear(), geom::OpenCuboidChannel3D::isNear(), and geom::OpenRectChannel2D::isNear().

Here is the call graph for this function:

Here is the caller graph for this function:

isPointInsideCuboid()

bool geom::isPointInsideCuboid	(	util::Point	x,
		util::Point	x_lbb,
		util::Point	x_rtf
	)

Checks if point is inside a cuboid.

Parameters

x	Point
x_lbb	Coordinate of left-bottom-back corner point
x_rtf	Coordinate of right-top-front corner point

Returns

bool True if point inside cuboid, else false

Definition at line 303 of file geomUtilFunctions.cpp.

                                                          {
  return !(util::isLess(x.d_x, x_lbb.d_x - 1.0E-12) or
           util::isLess(x.d_y, x_lbb.d_y - 1.0E-12) or
           util::isLess(x.d_z, x_lbb.d_z - 1.0E-12) or
           util::isGreater(x.d_x, x_rtf.d_x + 1.0E-12) or
           util::isGreater(x.d_y, x_rtf.d_y + 1.0E-12) or
           util::isGreater(x.d_z, x_rtf.d_z + 1.0E-12));
}

References util::Point::d_x, util::Point::d_y, util::Point::d_z, util::isGreater(), and util::isLess().

Referenced by geom::Cube::isInside(), and geom::Cuboid::isInside().

Here is the call graph for this function:

Here is the caller graph for this function:

isPointInsideCylinder() [1/2]

bool geom::isPointInsideCylinder	(	const util::Point &	p,
		const double &	length,
		const double &	radius,
		const util::Point &	axis
	)

Returns true if point is inside the cylinder.

Parameters

p	Point
length	Length of cylinder
radius	Radius of cylinder
axis	Axis of cylinder

Returns

True If point inside cylinder otherwise false

Definition at line 313 of file geomUtilFunctions.cpp.

                                {
 
  double p_dot_a = p * axis;
  if (p_dot_a > length or p_dot_a < 0.)
    return false;
  else {
 
    auto p_parallel = p - p_dot_a * axis;
 
    return p_parallel.lengthSq() < radius * radius;
  }
}

References util::Point::lengthSq().

Here is the call graph for this function:

isPointInsideCylinder() [2/2]

bool geom::isPointInsideCylinder	(	const util::Point &	p,
		const double &	radius,
		const util::Point &	x1,
		const util::Point &	x2
	)

Returns true if point is inside the cylinder.

Parameters

p	Point
radius	Radius of cylinder
x1	Point at the center of cross-section at s=0
x2	Point at the center of cross-section at s=L

Returns

True If point inside cylinder otherwise false

Definition at line 327 of file geomUtilFunctions.cpp.

                                                                        {
 
  auto p_new = p - x1;
  auto a = x2 - x1;
  double p_dot_a = p_new * a;
 
  // note here we should 1 if a is not normalized
  if (p_dot_a > 1. or p_dot_a < 0.)
    return false;
  else {
 
    auto p_parallel = p_new - p_dot_a * a;
 
    return p_parallel.lengthSq() < radius * radius;
  }
}

References util::Point::lengthSq().

Here is the call graph for this function:

isPointInsideEllipse() [1/2]

bool geom::isPointInsideEllipse	(	const util::Point &	p,
		const util::Point &	center,
		const std::vector< double > &	radius_vec,
		unsigned int	dim
	)

Returns true if point is inside the ellipsoid.

Parameters

p	Point
center	Center of ellipse
radius_vec	Vector of radius describing ellipse
dim	Dimension

Returns

True If point inside otherwise false

Definition at line 345 of file geomUtilFunctions.cpp.

                                                 {
 
  double d = 0.;
  auto x = p - center;
  for (unsigned int i=0; i<dim; i++)
    d += x[i] * x[i] / (radius_vec[i] * radius_vec[i]);
 
  return d < 1.;
}

isPointInsideEllipse() [2/2]

bool geom::isPointInsideEllipse	(	const util::Point &	p,
		const util::Point &	center,
		const std::vector< double > &	radius_vec,
		unsigned int	dim,
		double &	d
	)

Returns true if point is inside the ellipsoid.

Also computes d = x^2 / r1^2 + y^2 / r2^2 + z^2 / r3^2

Parameters

p	Point
center	Center of ellipse
radius_vec	Vector of radius describing ellipse
dim	Dimension
d

Returns

True If point inside otherwise false

Definition at line 356 of file geomUtilFunctions.cpp.

                                                            {
 
  d = 0.;
  auto x = p - center;
  for (unsigned int i=0; i<dim; i++)
    d += x[i] * x[i] / (radius_vec[i] * radius_vec[i]);
 
  return d < 1.;
}

isPointInsideRectangle() [1/2]

bool geom::isPointInsideRectangle	(	util::Point	x,
		double	x_min,
		double	x_max,
		double	y_min,
		double	y_max
	)

Checks if point is inside a rectangle.

Parameters

x	Point
x_min	X coordinate of left-bottom corner point
x_max	X coordinate of right-top corner point
y_min	Y coordinate of left-bottom corner point
y_max	Y coordinate of right-top corner point

Returns

bool True if point inside rectangle, else false

Definition at line 248 of file geomUtilFunctions.cpp.

                                                          {
 
  return !(util::isLess(x.d_x, x_min - 1.0E-12) or
           util::isLess(x.d_y, y_min - 1.0E-12) or
           util::isGreater(x.d_x, x_max + 1.0E-12) or
           util::isGreater(x.d_y, y_max + 1.0E-12));
}

References util::Point::d_x, util::Point::d_y, util::isGreater(), and util::isLess().

Referenced by geom::Square::isInside(), and geom::Rectangle::isInside().

Here is the call graph for this function:

Here is the caller graph for this function:

isPointInsideRectangle() [2/2]

bool geom::isPointInsideRectangle	(	util::Point	x,
		util::Point	x_lb,
		util::Point	x_rt
	)

Checks if point is inside a rectangle.

Parameters

x	Point
x_lb	Coordinate of left-bottom corner point
x_rt	Coordinate of right-top corner point

Returns

bool True if point inside rectangle, else false

Definition at line 258 of file geomUtilFunctions.cpp.

                                                            {
  return !(util::isLess(x.d_x, x_lb.d_x - 1.0E-12) or
           util::isLess(x.d_y, x_lb.d_y - 1.0E-12) or
           util::isGreater(x.d_x, x_rt.d_x + 1.0E-12) or
           util::isGreater(x.d_y, x_rt.d_y + 1.0E-12));
}

References util::Point::d_x, util::Point::d_y, util::isGreater(), and util::isLess().

Here is the call graph for this function:

makeExampleGeomObject()

std::shared_ptr< GeomObject > geom::makeExampleGeomObject	(	const std::string &	geom_type,
		const util::Point &	c,
		double	s
	)

One-liner: createGeomObject(exampleGeomParams(...)). Prefer this over per-class static factories so annulus and composite types stay in one place.

Definition at line 1334 of file geomObjectsUtil.cpp.

                                                                {
      std::shared_ptr<GeomObject> obj;
      createGeomObject(geom_type, exampleGeomParams(geom_type, c, s), {}, {}, obj, false);
      return obj;
    }

References createGeomObject(), and exampleGeomParams().

Referenced by anonymous_namespace{testMeshGen.cpp}::builtinMeshCheckForGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

mapSimilarity()

util::Point geom::mapSimilarity ( const util::Point &  x, const util::Point &  pivotDefault, const util::Point &  t, double  scale, double  angle, const util::Point &  axis, const util::Point *  rotationPoint  )

inline

Rigid similarity then displacement: \(\mathbf y = \mathbf p + s\,\mathbf R(\mathbf x-\mathbf p) + \mathbf t\). Pivot \(\mathbf p\) is rotationPoint if non-null, else pivotDefault (typically old center).

Definition at line 55 of file geomObjects.h.

                                      {
    const util::Point &p = (rotationPoint != nullptr) ? *rotationPoint : pivotDefault;
    return p + util::rotate(x - p, angle, axis) * scale + t;
  }

References util::rotate().

Referenced by geom::Plane::transform(), geom::Line::transform(), geom::Triangle::transform(), geom::Square::transform(), geom::Rectangle::transform(), geom::Hexagon::transform(), geom::Drum2D::transform(), geom::Cube::transform(), geom::Cuboid::transform(), geom::Circle::transform(), geom::Ellipse::transform(), geom::Sphere::transform(), geom::Ellipsoid::transform(), geom::Cylinder::transform(), and geom::OpenCuboidChannel3D::transform().

Here is the call graph for this function:

Here is the caller graph for this function:

pointDistanceLine()

double geom::pointDistanceLine	(	const util::Point &	p,
		const std::pair< util::Point, util::Point > &	line
	)

Compute distance between point and line.

Parameters

p	Point
line	Line

Returns

Value Distance

Definition at line 519 of file geomUtilFunctions.cpp.

                                                                    {
 
  // line vector
  auto v = line.second - line.first;
 
  // vector from 1st point of line to p
  auto w = p - line.first;
 
  // project w onto v and add 1st point to get projected point's location
  auto w_on_line = line.first + (w * v) * v / v.lengthSq();
 
  return (p - w_on_line).length();
}

References util::Point::lengthSq().

Here is the call graph for this function:

pointDistancePlane()

double geom::pointDistancePlane	(	const util::Point &	p,
		const std::pair< util::Point, util::Point > &	plane
	)

Compute distance between point and plane.

Parameters

p	Point
plane	Plane given by pair of normal and one point which it contains

Returns

Value Distance

Definition at line 557 of file geomUtilFunctions.cpp.

                                                                      {
 
  // if plane is given by unit normal n and a point a which is contained in it
  // then the distance of point p from plane is
  // |(p - a) dot n| / |n|
 
  auto pa = p - plane.second;
  return std::abs(pa * plane.first) / plane.first.length();
}

References util::Point::length().

Here is the call graph for this function:

pointDistanceSegment()

double geom::pointDistanceSegment	(	const util::Point &	p,
		const std::pair< util::Point, util::Point > &	line
	)

Compute distance between point and line.

Parameters

p	Point
line	Line

Returns

Value Distance

Definition at line 534 of file geomUtilFunctions.cpp.

                                                                                    {
 
  // line vector
  auto v = line.second - line.first;
 
  // vector from 1st point of line to p
  auto w = p - line.first;
 
  // determine if w is on left side or right side of line
  double w_dot_v = w * v;
  if (w_dot_v < 1.0E-12)
    return (p - line.first).length();
 
  if (w_dot_v > v.lengthSq() - 1.0E-12)
    return (p - line.second).length();
 
  // project w onto v and add 1st point to get projected point's location
  auto w_on_line = line.first + w_dot_v * v / v.lengthSq();
 
  return (p - w_on_line).length();
}

References util::Point::length().

Here is the call graph for this function:

readGeometry()

void geom::readGeometry	(	const json &	j,
		geom::GeomData &	geomData
	)

Definition at line 1400 of file geomObjectsUtil.cpp.

                                                           {
 
    if (j.find("Type") == j.end()) {
      throw std::invalid_argument(
          util::io::Msg()
          << "Error: Geometry type not found in json file.\n");
    }
    geomData.d_geomName = j.at("Type");
 
    if (geomData.d_geomName == "complex") {
      if ((j.find("Vec_type") == j.end()) or (j.find("Vec_flag") == j.end())) {
        throw std::invalid_argument(
            util::io::Msg()
            << "Error: Geometry type and/or flag not found in json file.\n");
      }
      geomData.d_geomComplexInfo.first = j.at("Vec_type").get<std::vector<std::string>>();
      geomData.d_geomComplexInfo.second = j.at("Vec_flag").get<std::vector<std::string>>();
    }
 
    if (j.find("Parameters") == j.end()) {
      throw std::invalid_argument(
          util::io::Msg()
          << "Error: Geometry parameters not found in json file.\n");
    }
 
    for (auto a: j.at("Parameters"))
      geomData.d_geomParams.push_back(a);
  }

References geom::GeomData::d_geomComplexInfo, geom::GeomData::d_geomName, and geom::GeomData::d_geomParams.

Referenced by inp::BCBaseDeck::readFromJson(), and inp::ParticleDeck::readParticleGeomFromJson().

Here is the caller graph for this function:

toPointBox()

std::pair< util::Point, util::Point > geom::toPointBox	(	const std::vector< double > &	p1,
		const std::vector< double > &	p2
	)

Create box from two coordinate data.

Parameters

p1	Point 1
p2	Point 2

Returns

Box Pair of corner points of box

Definition at line 651 of file geomUtilFunctions.cpp.

                                                      {
  auto q1 = util::Point(p1[0], p1[1], p1[2]);
  auto q2 = util::Point(p2[0], p2[1], p2[2]);
  return {q1, q2};
}

triangleArea()

double geom::triangleArea	(	const util::Point &	x1,
		const util::Point &	x2,
		const util::Point &	x3
	)

Compute area of triangle.

Parameters

x1	Vertex 1
x2	Vertex 2
x3	Vertex 3

Returns

area Area of triangle

Definition at line 659 of file geomUtilFunctions.cpp.

                                         {
  return 0.5 * ((x2.d_x - x1.d_x) * (x3.d_y - x1.d_y) -
                (x3.d_x - x1.d_x) * (x2.d_y - x1.d_y));
}

References util::Point::d_x, and util::Point::d_y.

Referenced by geom::Triangle::isInside(), geom::Triangle::isNearBoundary(), test::testUtilMethods(), and geom::Triangle::volume().

Here is the caller graph for this function:

writeGeometry()

void geom::writeGeometry	(	json &	j,
		const geom::GeomData &	geomData
	)

Definition at line 1389 of file geomObjectsUtil.cpp.

                                                            {
    j["Type"] = geomData.d_geomName;
 
    if (geomData.d_geomName == "complex") {
      j["Vec_type"] = geomData.d_geomComplexInfo.first;
      j["Vec_flag"] = geomData.d_geomComplexInfo.second;
    }
 
    j["Parameters"] = geomData.d_geomParams;
  }

References geom::GeomData::d_geomComplexInfo, geom::GeomData::d_geomName, and geom::GeomData::d_geomParams.

Referenced by anonymous_namespace{main.cpp}::buildInputJson(), inp::BCBaseDeck::getExampleJson(), and inp::ParticleDeck::getParticleGeomExampleJson().

Here is the caller graph for this function:

Variable Documentation

acceptable_geometries

const std::vector<std::string> geom::acceptable_geometries

Initial value:

= {"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"}

List of acceptable geometries for particles in PeriDEM.

Definition at line 127 of file geomObjectsUtil.h.

                                                   {"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"};

Referenced by getAcceptableGeometries().

geom_type_to_dim

const std::map<std::string, size_t> geom::geom_type_to_dim

Initial value:

= {
    {"circle", 2},
    {"ellipse", 2},
    {"square", 2},
    {"rectangle", 2},
    {"hexagon", 2},
    {"triangle", 2},
    {"drum2d", 2},
    {"sphere", 3},
    {"ellipsoid", 3},
    {"cube", 3},
    {"cuboid", 3},
    {"cylinder", 3},
    {"open_rect_channel_2d", 2},
    {"open_cuboid_channel_3d", 3},
    {"plane", 3},
    {"line", 1}
  }

Geometry type to dimension map.

Definition at line 27 of file geomObjects.h.

                                                     {
    {"circle", 2},
    {"ellipse", 2},
    {"square", 2},
    {"rectangle", 2},
    {"hexagon", 2},
    {"triangle", 2},
    {"drum2d", 2},
    {"sphere", 3},
    {"ellipsoid", 3},
    {"cube", 3},
    {"cuboid", 3},
    {"cylinder", 3},
    {"open_rect_channel_2d", 2},
    {"open_cuboid_channel_3d", 3},
    {"plane", 3},
    {"line", 1}
  };

Referenced by getGeomTypeToDim().