CSGSphere creates an internal representation of a Constructive Solid Geometry (CSG) sphere, represented in the form (x - x0)^2 + (y - y0)^2 + (z - z0)^2 = r^2. More...

#include <CSGSphere.h>

Inheritance diagram for CSG::CSGSphere:

[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
	CSGSphere (const std::string &name, const Point &center, const Real r)
	Construct a new CSGSphere surface.

	CSGSphere (const std::string &name, const Real r)
	Construct a new CSGSphere surface.

virtual	~CSGSphere ()=default
	Destructor.

virtual std::unordered_map< std::string, Real >	getCoeffs () const override
	Get the coefficients (x0, y0, z0, r) for the equation of a sphere (x - x0)^2 + (y - y0)^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 sphere

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 CSGSphere 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 sphere.

Real	_y0
	Value of y0 in equation of sphere.

Real	_z0
	Value of z0 in equation of sphere.

Real	_r
	Value of r in equation of sphere.

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

CSGSphere creates an internal representation of a Constructive Solid Geometry (CSG) sphere, represented in the form (x - x0)^2 + (y - y0)^2 + (z - z0)^2 = r^2.

Definition at line 23 of file CSGSphere.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

◆ CSGSphere() [1/2]

CSG::CSGSphere::CSGSphere	(	const std::string &	name,
		const Point &	center,
		const Real	r
	)

Construct a new CSGSphere surface.

Parameters

name	unique name for the sphere surface
center	center point of sphere
r	radius of sphere

Definition at line 15 of file CSGSphere.C.

  : CSGSurface(name), _x0(center(0)), _y0(center(1)), _z0(center(2)), _r(r)
{
  checkRadius();
}

◆ CSGSphere() [2/2]

CSG::CSGSphere::CSGSphere	(	const std::string &	name,
		const Real	r
	)

Construct a new CSGSphere surface.

Parameters

name	unique name for the sphere surface
r	radius of sphere

Definition at line 21 of file CSGSphere.C.

  : CSGSurface(name), _x0(0.0), _y0(0.0), _z0(0.0), _r(r)
{
  checkRadius();
}

◆ ~CSGSphere()

virtual CSG::CSGSphere::~CSGSphere ( )

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::CSGSphere::checkRadius ( ) const

protected

Definition at line 46 of file CSGSphere.C.

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

Referenced by CSGSphere(), and CSGSphere().

◆ clone()

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

inlineoverrideprotectedvirtual

create clone of CSGSphere object

Returns: std::unordered_map<CSGSurface> unique_ptr to cloned sphere

Implements CSG::CSGSurface.

Definition at line 70 of file CSGSphere.h.

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

◆ evaluateSurfaceEquationAtPoint()

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

overridevirtual

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

Parameters

p point

Returns: evaluation of point based on surface equation

Implements CSG::CSGSurface.

Definition at line 35 of file CSGSphere.C.

{
  // Compute distance from the sphere center to determine if inside (< r^2)
  // or outside (> r^2) the sphere
  const Real dist_sq =
      Utility::pow<2>((p(0) - _x0)) + Utility::pow<2>((p(1) - _y0)) + 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::CSGSphere::getCoeffs ( ) const

overridevirtual

Get the coefficients (x0, y0, z0, r) for the equation of a sphere (x - x0)^2 + (y - y0)^2 + (z - z0)^2 = r^2.

Returns: map of coefficients (x0, y0, z0, and r) and their values

Implements CSG::CSGSurface.

Definition at line 28 of file CSGSphere.C.

{
  std::unordered_map<std::string, Real> coeffs = {{"x0", _x0}, {"y0", _y0}, {"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(), clone(), CSG::CSGXCylinder::clone(), CSG::CSGYCylinder::clone(), CSG::CSGZCylinder::clone(), CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGSurface::getName(), and CSG::CSGSurface::setName().

◆ _r

Real CSG::CSGSphere::_r

protected

Value of r in equation of sphere.

Definition at line 88 of file CSGSphere.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::CSGSphere::_x0

protected

Value of x0 in equation of sphere.

Definition at line 79 of file CSGSphere.h.

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

◆ _y0

Real CSG::CSGSphere::_y0

protected

Value of y0 in equation of sphere.

Definition at line 82 of file CSGSphere.h.

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

◆ _z0

Real CSG::CSGSphere::_z0

protected

Value of z0 in equation of sphere.

Definition at line 85 of file CSGSphere.h.

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

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

include/csg/CSGSphere.h
src/csg/CSGSphere.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ Halfspace

Constructor & Destructor Documentation

◆ CSGSphere() [1/2]

◆ CSGSphere() [2/2]

◆ ~CSGSphere()

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

◆ _y0

◆ _z0