CSG::CSGYCylinder Class Reference

CSGYCylinder creates an internal representation of a Constructive Solid Geometry (CSG) y-axis aligned cylinder, represented in the following form (x - x0)^2 + (z - z0)^2 = r^2. More...

#include <CSGYCylinder.h>

Inheritance diagram for CSG::CSGYCylinder:

Public Types
enum	Halfspace { Halfspace::POSITIVE, Halfspace::NEGATIVE }
	Enum for the sign of the half-space being represented by a point and surface. More...

Public Member Functions
	CSGYCylinder (const std::string &name, const Real x0, const Real z0, const Real r)
	Construct a cylinder surface aligned with the y axis. More...
virtual	~CSGYCylinder ()=default
	Destructor. More...
virtual std::unordered_map< std::string, Real >	getCoeffs () const override
	Get the coefficients (x0, z0, and r) that define the cylindrical surface with the equation: (x - x0)^2 + (z - z0)^2 = r^2. More...
virtual Real	evaluateSurfaceEquationAtPoint (const Point &p) const override
	given a point, determine its evaluation based on the equation of the cylinder More...
const std::string &	getSurfaceType () const
	Get the Surface Type. More...
CSGSurface::Halfspace	getHalfspaceFromPoint (const Point &p) const
	given a point, determine if it is in the positive or negative half-space for the surface More...
const std::string &	getName () const
	Get the name of surface. More...
bool	operator== (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are equal. More...
bool	operator!= (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are not equal. More...
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const
	Get the list of transformations. More...
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const
	Get the transformations of this object with string representations for types. More...

Static Public Member Functions
static bool	isValidTransformationValue (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Check if the transformation value is valid for the given type. More...
static std::string	getTransformationTypeString (TransformationType type)
	Get the string representation of the transformation type. More...

Protected Member Functions
virtual std::unique_ptr< CSGSurface >	clone () const override
	create clone of CSGYCylinder object More...
void	checkRadius () const
void	setName (const std::string &name)
void	addTransformation (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Add a transformation to the list of transformations. More...
Point	applyReverseTransformsToPoint (Point p) const
	update the value of point p by applying the inverse of the list of transformations to the point More...
	FRIEND_TEST (CSGSurfaceTest, testSetName)
	Friends for unit testing. More...
	FRIEND_TEST (CSGSurfaceTest, testSurfaceEquality)
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing. More...
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

Protected Attributes
Real	_x0
	Value of x0 in equation of an y-axis aligned cylinder. More...
Real	_z0
	Value of z0 in equation of an y-axis aligned cylinder. More...
Real	_r
	Value of r in equation of an y-axis aligned cylinder. More...
std::string	_name
	Name of surface. More...
const std::string	_surface_type
	Type of surface that is being represented string is taken directly from the surface class name. More...
std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object. More...

Detailed Description

CSGYCylinder creates an internal representation of a Constructive Solid Geometry (CSG) y-axis aligned cylinder, represented in the following form (x - x0)^2 + (z - z0)^2 = r^2.

Definition at line 23 of file CSGYCylinder.h.

Member Enumeration Documentation

Halfspace

enum CSG::CSGSurface::Halfspace

stronginherited

Enum for the sign of the half-space being represented by a point and surface.

Enumerator
POSITIVE
NEGATIVE

Definition at line 30 of file CSGSurface.h.

  {
    POSITIVE,
    NEGATIVE
  };

Constructor & Destructor Documentation

CSGYCylinder()

CSG::CSGYCylinder::CSGYCylinder	(	const std::string &	name,
		const Real	x0,
		const Real	z0,
		const Real	r
	)

Construct a cylinder surface aligned with the y axis.

Parameters

name	unique name of surface
x0	x coordinate of center
z0	z coordinate of center
r	radius

Definition at line 15 of file CSGYCylinder.C.

  : CSGSurface(name, MooseUtils::prettyCppType<CSGYCylinder>()), _x0(x0), _z0(z0), _r(r)
{
  checkRadius();
}

~CSGYCylinder()

virtual CSG::CSGYCylinder::~CSGYCylinder ( )

virtualdefault

Destructor.

Member Function Documentation

addTransformation()

void CSG::CSGTransformationHelper::addTransformation ( TransformationType  type, const std::tuple< Real, Real, Real > &  values  )

protectedinherited

Add a transformation to the list of transformations.

Parameters

type	The type of transformation
values	The values for the transformation

Definition at line 16 of file CSGTransformationHelper.C.

{
  if (!isValidTransformationValue(type, values))
    mooseError("Invalid transformation values provided for transformation type " +
               getTransformationTypeString(type));
  _transformations.emplace_back(type, values);
}

applyReverseTransformsToPoint()

Point CSG::CSGTransformationHelper::applyReverseTransformsToPoint ( Point  p ) const

protectedinherited

update the value of point p by applying the inverse of the list of transformations to the point

Parameters

p	point to transform

Returns

transformed point

Definition at line 74 of file CSGTransformationHelper.C.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint().

{
  // iterate list of transformations in reverse and apply the inverse operation
  for (auto it = _transformations.rbegin(); it != _transformations.rend(); ++it)
  {
    auto trans_type = it->first;
    auto val = it->second;

    if (trans_type == TransformationType::TRANSLATION)
    {
      Point offset(std::get<0>(val), std::get<1>(val), std::get<2>(val));
      p -= offset;
    }
    else if (trans_type == TransformationType::SCALE)
    {
      Point scale(std::get<0>(val), std::get<1>(val), std::get<2>(val));
      for (int i = 0; i < 3; ++i)
        p(i) /= scale(i);
    }
    else if (trans_type == TransformationType::ROTATION)
    {
      // get the transpose of the original rotation matrix and apply to point p
      const auto rot_matrix = RealTensorValue::intrinsic_rotation_matrix(
          std::get<0>(val), std::get<1>(val), std::get<2>(val));
      const auto rot_transpose = rot_matrix.transpose();
      p = rot_transpose * p;
    }
    else
      mooseError("Transformation type is not recognized.");
  }
  return p;
}

checkRadius()

void CSG::CSGYCylinder::checkRadius ( ) const

protected

Definition at line 39 of file CSGYCylinder.C.

Referenced by CSGYCylinder().

{
  if (_r <= 0.0)
    mooseError("Radius of y-cylinder must be positive.");
}

clone()

virtual std::unique_ptr<CSGSurface> CSG::CSGYCylinder::clone ( ) const

inlineoverrideprotectedvirtual

create clone of CSGYCylinder object

Returns

std::unordered_map<CSGSurface> unique_ptr to cloned y-cylinder

Implements CSG::CSGSurface.

Definition at line 63 of file CSGYCylinder.h.

  {
    return std::make_unique<CSGYCylinder>(_name, _x0, _z0, _r);
  }

evaluateSurfaceEquationAtPoint()

Real CSG::CSGYCylinder::evaluateSurfaceEquationAtPoint ( const Point &  p ) const

overridevirtual

given a point, determine its evaluation based on the equation of the cylinder

Parameters

p

point

Returns

evaluation of point based on surface equation

Implements CSG::CSGSurface.

Definition at line 29 of file CSGYCylinder.C.

{
  // Compute distance from the cylinder center to determine if inside (< r^2)
  // or outside (> r^2) the cylinder
  const Real dist_sq = Utility::pow<2>((p(0) - _x0)) + Utility::pow<2>((p(2) - _z0));

  return dist_sq - Utility::pow<2>(_r);
}

FRIEND_TEST() [1/4]

CSG::CSGTransformationHelper::FRIEND_TEST ( CSGSurfaceTest  , testHalfspaceWithTransform    )

protectedinherited

Friends for unit testing.

FRIEND_TEST() [2/4]

CSG::CSGTransformationHelper::FRIEND_TEST ( CSGSurfaceTest  , testHalfspaceWithNullTransform    )

protectedinherited

FRIEND_TEST() [3/4]

CSG::CSGSurface::FRIEND_TEST ( CSGSurfaceTest  , testSetName    )

protectedinherited

Friends for unit testing.

FRIEND_TEST() [4/4]

CSG::CSGSurface::FRIEND_TEST ( CSGSurfaceTest  , testSurfaceEquality    )

protectedinherited

getCoeffs()

std::unordered_map< std::string, Real > CSG::CSGYCylinder::getCoeffs ( ) const

overridevirtual

Get the coefficients (x0, z0, and r) that define the cylindrical surface with the equation: (x - x0)^2 + (z - z0)^2 = r^2.

Returns

map of coefficients to their value

Implements CSG::CSGSurface.

Definition at line 22 of file CSGYCylinder.C.

{
  std::unordered_map<std::string, Real> coeffs = {{"x0", _x0}, {"z0", _z0}, {"r", _r}};
  return coeffs;
}

getHalfspaceFromPoint()

CSGSurface::Halfspace CSG::CSGSurface::getHalfspaceFromPoint ( const Point &  p ) const

inherited

given a point, determine if it is in the positive or negative half-space for the surface

Parameters

p

point

Returns

sign of the half-space

Definition at line 23 of file CSGSurface.C.

{
  // if transformations are present on the surface, apply them in reverse to the point and pass that
  // new point to the evaluation to ensure transformations are considered.

  // Create a local transformed copy - the original p in the calling scope is NOT modified
  const Point p_trans = getTransformations().size() ? applyReverseTransformsToPoint(p) : p;

  auto eval = evaluateSurfaceEquationAtPoint(p_trans);
  if (MooseUtils::absoluteFuzzyGreaterThan(eval, 0))
    return Halfspace::POSITIVE;
  else if (MooseUtils::absoluteFuzzyLessThan(eval, 0))
    return Halfspace::NEGATIVE;
  else
    mooseError("Point ",
               p,
               " used to determine halfspace evaluation lies on the surface ",
               _name,
               ", leading to an ambiguously defined halfspace.");
}

getName()

const std::string& CSG::CSGSurface::getName ( ) const

inlineinherited

Get the name of surface.

Returns

std::string name of surface

Definition at line 95 of file CSGSurface.h.

Referenced by CSG::CSGSurfaceList::addSurface(), CSG::CSGBase::addTransformation(), CSG::CSGBase::checkSurfaceInBase(), CSG::CSGBase::deleteSurface(), CSG::CSGSurface::operator==(), and CSG::CSGSurfaceList::renameSurface().

{ return _name; }

getSurfaceType()

const std::string& CSG::CSGSurface::getSurfaceType ( ) const

inlineinherited

Get the Surface Type.

Returns

type of surface

Definition at line 61 of file CSGSurface.h.

Referenced by CSG::CSGSurface::operator==().

{ return _surface_type; }

getTransformations()

const std::vector<std::pair<TransformationType, std::tuple<Real, Real, Real> > >& CSG::CSGTransformationHelper::getTransformations ( ) const

inlineinherited

Get the list of transformations.

Returns

The list of transformations

Definition at line 47 of file CSGTransformationHelper.h.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGUniverse::operator==(), CSG::CSGSurface::operator==(), CSG::CSGCell::operator==(), and CSG::CSGLattice::operator==().

  {
    return _transformations;
  }

getTransformationsAsStrings()

std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > > CSG::CSGTransformationHelper::getTransformationsAsStrings ( ) const

inherited

Get the transformations of this object with string representations for types.

Returns

Vector of transformation pairs with string representations for types

Definition at line 65 of file CSGTransformationHelper.C.

{
  std::vector<std::pair<std::string, std::tuple<Real, Real, Real>>> result;
  for (const auto & transform_pair : _transformations)
    result.emplace_back(getTransformationTypeString(transform_pair.first), transform_pair.second);
  return result;
}

getTransformationTypeString()

std::string CSG::CSGTransformationHelper::getTransformationTypeString ( TransformationType  type )

staticinherited

Get the string representation of the transformation type.

Parameters

type	The transformation type

Returns

String name of the transformation type

Definition at line 56 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation(), and CSG::CSGTransformationHelper::getTransformationsAsStrings().

{
  // Set the enum to the value and convert it to string
  MooseEnum enum_copy = transformation_type_enum;
  enum_copy = static_cast<int>(type);
  return std::string(enum_copy);
}

isValidTransformationValue()

bool CSG::CSGTransformationHelper::isValidTransformationValue ( TransformationType  type, const std::tuple< Real, Real, Real > &  values  )

staticinherited

Check if the transformation value is valid for the given type.

Parameters

type	The type of transformation
values	The values for the transformation

Returns

True if the values are valid for the type

Definition at line 26 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation().

{
  // Additional validation specific to each transformation type could be added here
  switch (type)
  {
    case TransformationType::TRANSLATION:
      // All translation values are inherently valid
      return true;

    case TransformationType::ROTATION:
      // Rotation uses euler notation; values are angles in degrees (phi, theta, psi)
      // For consistency with TransformGenerator, there are no restrictions on the angles
      // phi: rotation around Z-axis
      // theta: rotation around new X-axis
      // psi: rotation around new Z-axis
      return true;

    case TransformationType::SCALE:
      // Scaling factors should be non-zero
      if (std::get<0>(values) == 0.0 || std::get<1>(values) == 0.0 || std::get<2>(values) == 0.0)
        return false;
      return true;

    default:
      mooseError("Unknown transformation type");
  }
}

operator!=()

bool CSG::CSGSurface::operator!= ( const CSGSurface &  other ) const

inherited

Operator overload for checking if two CSGSurface objects are not equal.

Definition at line 54 of file CSGSurface.C.

{
  return !(*this == other);
}

operator==()

bool CSG::CSGSurface::operator== ( const CSGSurface &  other ) const

inherited

Operator overload for checking if two CSGSurface objects are equal.

Definition at line 45 of file CSGSurface.C.

{
  return (this->getName() == other.getName()) &&
         (this->getSurfaceType() == other.getSurfaceType()) &&
         (this->getCoeffs() == other.getCoeffs()) &&
         (this->getTransformations() == other.getTransformations());
}

setName()

void CSG::CSGSurface::setName ( const std::string &  name )

inlineprotectedinherited

Definition at line 113 of file CSGSurface.h.

{ _name = name; }

Member Data Documentation

_name

std::string CSG::CSGSurface::_name

protectedinherited

Name of surface.

Definition at line 116 of file CSGSurface.h.

Referenced by CSG::CSGXCylinder::clone(), clone(), CSG::CSGZCylinder::clone(), CSG::CSGSphere::clone(), CSG::CSGPlane::clone(), CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGSurface::getName(), and CSG::CSGSurface::setName().

_r

Real CSG::CSGYCylinder::_r

protected

Value of r in equation of an y-axis aligned cylinder.

Definition at line 78 of file CSGYCylinder.h.

Referenced by checkRadius(), clone(), evaluateSurfaceEquationAtPoint(), and getCoeffs().

_surface_type

const std::string CSG::CSGSurface::_surface_type

protectedinherited

Type of surface that is being represented string is taken directly from the surface class name.

Definition at line 120 of file CSGSurface.h.

Referenced by CSG::CSGSurface::getSurfaceType().

_transformations

std::vector<std::pair<TransformationType, std::tuple<Real, Real, Real> > > CSG::CSGTransformationHelper::_transformations

protectedinherited

List of transformations applied to this object.

Definition at line 92 of file CSGTransformationHelper.h.

Referenced by CSG::CSGTransformationHelper::addTransformation(), CSG::CSGTransformationHelper::applyReverseTransformsToPoint(), CSG::CSGTransformationHelper::getTransformations(), and CSG::CSGTransformationHelper::getTransformationsAsStrings().

_x0

Real CSG::CSGYCylinder::_x0

protected

Value of x0 in equation of an y-axis aligned cylinder.

Definition at line 72 of file CSGYCylinder.h.

Referenced by clone(), evaluateSurfaceEquationAtPoint(), and getCoeffs().

_z0

Real CSG::CSGYCylinder::_z0

protected

Value of z0 in equation of an y-axis aligned cylinder.

Definition at line 75 of file CSGYCylinder.h.

Referenced by clone(), evaluateSurfaceEquationAtPoint(), and getCoeffs().

---

The documentation for this class was generated from the following files:

• include/csg/CSGYCylinder.h
• src/csg/CSGYCylinder.C