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:

[legend]

Public Types
enum class	Halfspace { POSITIVE , 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.

virtual	~CSGYCylinder ()=default
	Destructor.

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.

virtual Real	evaluateSurfaceEquationAtPoint (const Point &p) const override
	given a point, determine its evaluation based on the equation of the cylinder

const std::string	getSurfaceType () const
	Get the Surface Type.

CSGSurface::Halfspace	getHalfspaceFromPoint (const Point &p) const
	given a point, determine if it is in the positive or negative half-space for the surface

const std::string &	getName () const
	Get the name of surface.

virtual bool	isEngUnit () const
	Whether this surface is an engineering unit.

bool	operator== (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are equal.

bool	operator!= (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are not equal.

const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const
	Get the list of transformations.

std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const
	Get the transformations of this object with string representations for types.

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.

static std::string	getTransformationTypeString (TransformationType type)
	Get the string representation of the transformation type.

Protected Member Functions
virtual std::unique_ptr< CSGSurface >	clone () const override
	create clone of CSGYCylinder object

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.

Point	applyReverseTransformsToPoint (Point p) const
	update the value of point p by applying the inverse of the list of transformations to the point


	FRIEND_TEST (CSGSurfaceTest, testSetName)
	Friends for unit testing.

	FRIEND_TEST (CSGSurfaceTest, testSurfaceEquality)


	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing.

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
Real	_x0
	Value of x0 in equation of an y-axis aligned cylinder.

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

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

std::string	_name
	Name of surface.

std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object.

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 class 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), _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);
}

Referenced by CSG::CSGBase::addTransformation(), CSG::CSGBase::expandEngUnit(), CSG::CSGBase::expandEngUnit(), and CSG::CSGBase::expandEngUnit().

◆ 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.

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

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

◆ checkRadius()

void CSG::CSGYCylinder::checkRadius ( ) const

protected

Definition at line 39 of file CSGYCylinder.C.

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

Referenced by CSGYCylinder().

◆ 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/5]

CSG::CSGTransformationHelper::FRIEND_TEST	(	CSGEngUnitTest	,
		testEngUnitEqual
	)

protectedinherited

◆ FRIEND_TEST() [2/5]

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

protectedinherited

◆ FRIEND_TEST() [3/5]

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

protectedinherited

Friends for unit testing.

◆ FRIEND_TEST() [4/5]

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

protectedinherited

Friends for unit testing.

◆ FRIEND_TEST() [5/5]

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 90 of file CSGSurface.h.

90{ return _name; }

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

◆ getSurfaceType()

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

inlineinherited

Get the Surface Type.

Returns: type of surface

Definition at line 53 of file CSGSurface.h.

  {
    return MooseUtils::prettyCppType(libMesh::demangle(typeid(*this).name()));
  }

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

◆ 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 51 of file CSGTransformationHelper.h.

  {
    return _transformations;
  }

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

◆ 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;
}

Referenced by CSG::CSGCellEngUnit::getTransformationsAsStrings(), CSG::CSGSurfaceEngUnit::getTransformationsAsStrings(), and CSG::CSGUniverseEngUnit::getTransformationsAsStrings().

◆ 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.

{
  // 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);
}

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

◆ isEngUnit()

virtual bool CSG::CSGSurface::isEngUnit ( ) const

inlinevirtualinherited

Whether this surface is an engineering unit.

Returns false for a plain CSGSurface; overridden to return true by the engineering unit types. Used to avoid a dynamic_cast on the common plain-surface comparison path (see operator==).

Returns: true if this object is a CSGEngUnit, otherwise false

Reimplemented in CSG::CSGSurfaceEngUnit.

Definition at line 101 of file CSGSurface.h.

101{ return false; }

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

◆ 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.

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

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

◆ operator!=()

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

inherited

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

Definition at line 65 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.

{
  // If both objects are engineering units, delegate to CSGEngUnit::operator== to avoid
  // calling getCoeffs(), which is not supported on engineering unit types. The isEngUnit()
  // check keeps the common plain-surface path free of any dynamic_cast; the casts below
  // only run once we know the objects are engineering units.
  if (isEngUnit())
  {
    if (other.isEngUnit())
      return *dynamic_cast<const CSGEngUnit *>(this) == *dynamic_cast<const CSGEngUnit *>(&other);
    return false; // an engineering unit cannot equal a plain surface
  }
 
  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 119 of file CSGSurface.h.

119{ _name = name; }

libMesh::Quality::name

std::string name(const ElemQuality q)

Member Data Documentation

◆ _name

std::string CSG::CSGSurface::_name

protectedinherited

Name of surface.

Definition at line 122 of file CSGSurface.h.

Referenced by CSG::CSGNPolygonUnit::clone(), CSG::CSGPlane::clone(), CSG::CSGSphere::clone(), CSG::CSGXCylinder::clone(), clone(), CSG::CSGZCylinder::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().

◆ _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 96 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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ Halfspace

Constructor & Destructor Documentation

◆ CSGYCylinder()

◆ ~CSGYCylinder()

Member Function Documentation

◆ addTransformation()

◆ applyReverseTransformsToPoint()

◆ checkRadius()

◆ clone()

◆ evaluateSurfaceEquationAtPoint()

◆ FRIEND_TEST() [1/5]

◆ FRIEND_TEST() [2/5]

◆ FRIEND_TEST() [3/5]

◆ FRIEND_TEST() [4/5]

◆ FRIEND_TEST() [5/5]

◆ getCoeffs()

◆ getHalfspaceFromPoint()

◆ getName()

◆ getSurfaceType()

◆ getTransformations()

◆ getTransformationsAsStrings()

◆ getTransformationTypeString()

◆ isEngUnit()

◆ isValidTransformationValue()

◆ operator!=()

◆ operator==()

◆ setName()

Member Data Documentation

◆ _name

◆ _r

◆ _transformations

◆ _x0

◆ _z0