CSG::CSGNPolygonUnit Class Reference

CSGNPolygonUnit is a CSGSurfaceEngUnit that represents a regular N-sided polygon (prismatic region) with its axis aligned with the z-axis. More...

#include <CSGNPolygonUnit.h>

Inheritance diagram for CSG::CSGNPolygonUnit:

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
	CSGNPolygonUnit (const std::string &name, int n_sides, Real apothem)
	Construct a new CSGNPolygonUnit.
Real	evaluateSurfaceEquationAtPoint (const Point &p) const override
	Evaluate the polygon's surface equation at the given point.
std::unordered_map< std::string, AttributeVariant >	getAttributes () const override
	Return the polygon attributes for this object.
int	getNumSides ()
	Get the number of sides for the polygon.
Real	getApothem ()
	Get the polygon apothem (center-to-flat distance)
Real	getSideLength ()
	Get the polygon side length.
Real	getRadius ()
	Get the the circumradius for the polygon (center-to-vertex distance)
std::unordered_map< std::string, Real >	getCoeffs () const override
	Always throws – coefficients are not defined for a surface engineering unit.
const std::string &	getName () const override
	Satisfy CSGEngUnit::getName() – resolved via CSGSurface::getName()
bool	isEngUnit () const override
	Engineering units report true so comparisons can skip the dynamic_cast fast path.
bool	operator== (const CSGSurfaceEngUnit &other) const
	Disambiguate == and != by forwarding to CSGEngUnit (name/property-based comparison)
bool	operator== (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are equal.
bool	operator== (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are equal.
bool	operator!= (const CSGSurfaceEngUnit &other) const
bool	operator!= (const CSGSurface &other) const
	Operator overload for checking if two CSGSurface objects are not equal.
bool	operator!= (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are not equal.
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const override
	Delegate to CSGSurface (CSGTransformationHelper)
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const override
	Delegate to CSGSurface (CSGTransformationHelper)
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	getBehavior () const
	Get the behavior of this engineering unit (surface (i.e.
const std::string	getUnitType () const
	Get the type name of this engineering unit.

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
std::unique_ptr< CSGSurface >	clone () const override
	Return a deep copy of this unit.
void	expandUnit () override
	Create N CSGPlane surfaces in _internal_base, one per polygon side.
CSGRegion	getExpandedRegion () const
	Return the CSGRegion formed by the expanded CSGSurfaces.
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
CSGBase &	getBase ()
	Get the internal CSGBase owned by this engineering unit.
std::unique_ptr< CSGBase >	releaseBase ()
	Transfer ownership of the internal CSGBase out of this unit.
	FRIEND_TEST (CSGEngUnitTest, testSurfUnit)
	Friends for unit testing.
	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
CSGRegion	_expanded_region
	Stores the result of expandUnit(); EMPTY until then.
std::string	_name
	Name of surface.
std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object.
std::unique_ptr< CSGBase >	_internal_base
	CSGBase populated by expandUnit(); joined into the parent CSGBase by expandEngUnit()
MooseEnum	_behavior {"SURFACE CELL UNIVERSE"}
	The basic CSG type this unit produces: "SURFACE", "CELL", or "UNIVERSE".

Private Member Functions
	FRIEND_TEST (CSGEngUnitTest, testPolygonUnitExpansion)
	FRIEND_TEST (CSGEngUnitTest, testPolygonUnitClone)

Private Attributes
const int	_n_sides
	Number of sides of the regular polygon.
const Real	_apothem
	Distance from the polygon center to the midpoint of each side.
std::vector< const CSGSurface * >	_planes
	Pointers to the expanded plane surfaces, populated during expandUnit()

Detailed Description

CSGNPolygonUnit is a CSGSurfaceEngUnit that represents a regular N-sided polygon (prismatic region) with its axis aligned with the z-axis.

The polygon is defined by N infinite planes, one per side, each oriented so that its inward normal points toward the center. The interior of the polygon is the intersection of the N negative half-spaces of those planes.

Implements:

• expandUnit(): creates N CSGPlane surfaces in _internal_base, one per side
• getExpandedRegion(): returns the intersection of the N half-spaces formed by the planes that containing the origin
• evaluateSurfaceEquationAtPoint(): returns the maximum plane evaluation over all N sides; negative means the point is inside, positive means outside
• clone(): returns a deep copy
• getAttributes(): returns n_sides, apothem

Definition at line 40 of file CSGNPolygonUnit.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

CSGNPolygonUnit()

CSG::CSGNPolygonUnit::CSGNPolygonUnit	(	const std::string &	name,
		int	n_sides,
		Real	apothem
	)

Construct a new CSGNPolygonUnit.

Parameters

name	unique name of the unit
n_sides	number of sides of the regular polygon (must be >= 3)
apothem	distance from the center to the midpoint of each side

Definition at line 17 of file CSGNPolygonUnit.C.

  : CSGSurfaceEngUnit(name), _n_sides(n_sides), _apothem(apothem)
{
  if (_n_sides < 3)
    mooseError("N-sided polygon engineering unit " + name + " must have 3 or more sides.");
  if (_apothem <= 0.0)
    mooseError("N-sided polygon engineering unit " + name + " apothem must be positive.");
}

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().

clone()

std::unique_ptr< CSGSurface > CSG::CSGNPolygonUnit::clone ( ) const

inlineoverrideprotectedvirtual

Return a deep copy of this unit.

Returns

unique_ptr to a new CSGNPolygonUnit with identical parameters

Implements CSG::CSGSurfaceEngUnit.

Definition at line 109 of file CSGNPolygonUnit.h.

  {
    return std::make_unique<CSGNPolygonUnit>(_name, _n_sides, _apothem);
  }

evaluateSurfaceEquationAtPoint()

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

overridevirtual

Evaluate the polygon's surface equation at the given point.

Returns the maximum signed plane-equation value over all N sides. A negative return value means the point lies inside the polygon; positive means outside; zero means on one of the sides.

This can be evaluated before expansion using the stored geometric parameters.

Parameters

p	point to evaluate

Returns

maximum signed distance from the point to any side (negative = inside)

Implements CSG::CSGSurfaceEngUnit.

Definition at line 27 of file CSGNPolygonUnit.C.

{
  // Condition for interior (negative value) vs exterior (positive value) for the polygon is:
  // for point (x, y), if the following is true for all values of k, then the point is "interior".
  // If any one value is positive, then the point is outside the polygon. Therefore, we calculate
  // the maximum value. If that max value remains negative, then getHalfspaceFromPoint will
  // correctly determine the point to be interior.
  //
  //    x*cos(2*pi*k/N) + y*sin(2*pi*k/N) <= apothem, for all k = 0..N-1
 
  Real max_val =
      -std::numeric_limits<Real>::max(); // initialize to extremely large negative (to be updated)
  for (int k = 0; k < _n_sides; ++k)
  {
    auto val =
        (p(0) * std::cos(2.0 * M_PI * k / _n_sides) + p(1) * std::sin(2.0 * M_PI * k / _n_sides)) -
        _apothem;
    if (val > max_val)
      max_val = val;
  }
  return max_val;
}

expandUnit()

void CSG::CSGNPolygonUnit::expandUnit ( )

overrideprotectedvirtual

Create N CSGPlane surfaces in _internal_base, one per polygon side.

Stores const pointers to the registered surfaces for use in getExpandedRegion().

Implements CSG::CSGSurfaceEngUnit.

Definition at line 57 of file CSGNPolygonUnit.C.

{
  // Polygon orientation assumes an infinite prism oriented with the z-axis.
  // The right-most face is parallel to the y-axis and is centered at the origin.
  // Equation for the kth face, where the 0th face is the right-most and A is the apothem, follows
  // this equation:
  //    x*cos(2*pi*k/N) + y*sin(2*pi*k/N) + z*0 = A
  // Coefficients for the plane ax + by + cz = d:
  //    a = cos(2*pi*k/N)
  //    b = sin(2*pi*k/N)
  //    c = 0.0
  //    d = A (apothem)
  //
  // Surface naming scheme: [UnitName]_expanded_surf_[k]
 
  Real a, b; // to be calculated based on side
  Real c = 0.0;
  Real d = _apothem;
 
  // Initialize region to be added to:
  Point p(0, 0, 0); // origin used for determining half-space
 
  // base name for surfaces
  std::string base_name = getName() + "_expanded_surf_";
 
  for (int k = 0; k < _n_sides; ++k)
  {
    auto sname = base_name + std::to_string(k);
    a = std::cos(2.0 * M_PI * k / _n_sides);
    b = std::sin(2.0 * M_PI * k / _n_sides);
    std::unique_ptr<CSG::CSGPlane> s_ptr = std::make_unique<CSG::CSGPlane>(sname, a, b, c, d);
    auto & surf = _internal_base->addSurface(std::move(s_ptr));
 
    // determine the half-space that contains the origin for this surface
    auto hp_type = surf.getHalfspaceFromPoint(p);
    // half-space region for this surface only (to be intersected below)
    auto hp = (hp_type == CSGSurface::Halfspace::POSITIVE) ? +surf : -surf;
 
    // start the region with first half-space, otherwise intersect with existing region
    if (_expanded_region.getRegionType() == CSGRegion::RegionType::EMPTY)
      _expanded_region = hp;
    else
      _expanded_region &= hp; // intersect with existing region
  }
}

FRIEND_TEST() [1/8]

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

protectedinherited

FRIEND_TEST() [2/8]

CSG::CSGNPolygonUnit::FRIEND_TEST ( CSGEngUnitTest  , testPolygonUnitClone    )

private

FRIEND_TEST() [3/8]

CSG::CSGNPolygonUnit::FRIEND_TEST ( CSGEngUnitTest  , testPolygonUnitExpansion    )

private

FRIEND_TEST() [4/8]

CSG::CSGSurfaceEngUnit::FRIEND_TEST ( CSGEngUnitTest  , testSurfUnit    )

protectedinherited

Friends for unit testing.

FRIEND_TEST() [5/8]

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

protectedinherited

FRIEND_TEST() [6/8]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [7/8]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [8/8]

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

protectedinherited

getApothem()

Real CSG::CSGNPolygonUnit::getApothem ( )

inline

Get the polygon apothem (center-to-flat distance)

Returns

apothem value

Definition at line 87 of file CSGNPolygonUnit.h.

{ return _apothem; }

getAttributes()

std::unordered_map< std::string, AttributeVariant > CSG::CSGNPolygonUnit::getAttributes ( ) const

overridevirtual

Return the polygon attributes for this object.

Returns

map containing: num_sides (int), apothem (Real)

Implements CSG::CSGEngUnit.

Definition at line 51 of file CSGNPolygonUnit.C.

{
  return {{"num_sides", _n_sides}, {"apothem", _apothem}};
}

getBase()

CSGBase & CSG::CSGEngUnit::getBase ( )

inlineprotectedinherited

Get the internal CSGBase owned by this engineering unit.

Returns

reference to the internal CSGBase

Definition at line 117 of file CSGEngUnit.h.

{ return *_internal_base; }

getBehavior()

const std::string CSG::CSGEngUnit::getBehavior ( ) const

inlineinherited

Get the behavior of this engineering unit (surface (i.e.

region), cell, or universe).

Returns "SURFACE", "CELL", or "UNIVERSE" depending on which intermediate EngUnit class the concrete type derives from. Set automatically at construction.

Returns

the behavior string

Definition at line 56 of file CSGEngUnit.h.

{ return _behavior; }

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

getCoeffs()

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

overridevirtualinherited

Always throws – coefficients are not defined for a surface engineering unit.

A surface engineering unit is described by its attributes (see getAttributes()), not by surface-equation coefficients, so this inherited CSGSurface method has no meaningful value on a unit. Expansion does not make it callable either: CSGBase::expandEngUnit() replaces the unit with plain CSGSurface object(s), and getCoeffs() is valid on those resulting surfaces, never on the unit itself.

The override exists only to satisfy the pure-virtual CSGSurface::getCoeffs()

Returns

never returns; always raises an error

Implements CSG::CSGSurface.

Definition at line 21 of file CSGSurfaceEngUnit.C.

{
  mooseError("CSGSurfaceEngUnit '",
             getName(),
             "' cannot getCoeffs(). Coefficients are only callable on CSGSurface(s) generated by "
             "expandUnit().");
}

getExpandedRegion()

CSGRegion CSG::CSGSurfaceEngUnit::getExpandedRegion ( ) const

protectedinherited

Return the CSGRegion formed by the expanded CSGSurfaces.

Checks that expandUnit() has already been called (via _expanded_region) before returning the stored result. Throws if called before expansion.

Returns

CSGRegion representing the negative halfspace of the surface engineering unit

Definition at line 30 of file CSGSurfaceEngUnit.C.

{
  // check if unit has been expanded first to define the region
  if (_expanded_region.getRegionType() == CSGRegion::RegionType::EMPTY)
    mooseError("getExpandedRegion() cannot be called on CSGSurfaceEngUnit '",
               getName(),
               "' before expandUnit() has been called.");
  return _expanded_region;
}

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::CSGSurfaceEngUnit::getName ( ) const

inlineoverridevirtualinherited

Satisfy CSGEngUnit::getName() – resolved via CSGSurface::getName()

Implements CSG::CSGEngUnit.

Definition at line 81 of file CSGSurfaceEngUnit.h.

{ return CSGSurface::getName(); }

Referenced by CSG::CSGBase::expandEngUnit(), expandUnit(), CSG::CSGSurfaceEngUnit::getCoeffs(), and CSG::CSGSurfaceEngUnit::getExpandedRegion().

getNumSides()

int CSG::CSGNPolygonUnit::getNumSides ( )

inline

Get the number of sides for the polygon.

Returns

number of sides

Definition at line 80 of file CSGNPolygonUnit.h.

{ return _n_sides; }

getRadius()

Real CSG::CSGNPolygonUnit::getRadius ( )

inline

Get the the circumradius for the polygon (center-to-vertex distance)

Returns

radius value

Definition at line 101 of file CSGNPolygonUnit.h.

{ return _apothem / (std::cos(M_PI / _n_sides)); }

getSideLength()

Real CSG::CSGNPolygonUnit::getSideLength ( )

inline

Get the polygon side length.

Returns

side length

Definition at line 94 of file CSGNPolygonUnit.h.

{ return 2.0 * _apothem * std::tan(M_PI / _n_sides); }

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::CSGSurfaceEngUnit::getTransformations ( ) const

inlineoverridevirtualinherited

Delegate to CSGSurface (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 92 of file CSGSurfaceEngUnit.h.

  {
    return CSGSurface::getTransformations();
  }

getTransformationsAsStrings()

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

inlineoverridevirtualinherited

Delegate to CSGSurface (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 99 of file CSGSurfaceEngUnit.h.

  {
    return CSGSurface::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().

getUnitType()

const std::string CSG::CSGEngUnit::getUnitType ( ) const

inlineinherited

Get the type name of this engineering unit.

Returns

the unit type string

Definition at line 63 of file CSGEngUnit.h.

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

Referenced by CSG::CSGCellEngUnit::getExpandedCell(), CSG::CSGUniverseEngUnit::getExpandedUniverse(), and CSG::CSGEngUnit::operator==().

isEngUnit()

bool CSG::CSGSurfaceEngUnit::isEngUnit ( ) const

inlineoverridevirtualinherited

Engineering units report true so comparisons can skip the dynamic_cast fast path.

Reimplemented from CSG::CSGSurface.

Definition at line 84 of file CSGSurfaceEngUnit.h.

{ return true; }

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!=() [1/3]

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

inherited

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

Definition at line 50 of file CSGEngUnit.C.

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

Referenced by CSG::CSGCellEngUnit::operator!=(), CSG::CSGSurfaceEngUnit::operator!=(), and CSG::CSGUniverseEngUnit::operator!=().

operator!=() [2/3]

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!=() [3/3]

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

inlineinherited

Definition at line 88 of file CSGSurfaceEngUnit.h.

{ return CSGEngUnit::operator!=(other); }

operator==() [1/3]

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

inherited

Operator overload for checking if two CSGEngUnit objects are equal.

Definition at line 34 of file CSGEngUnit.C.

{
  if (getName() != other.getName())
    return false;
  if (getBehavior() != other.getBehavior())
    return false;
  if (getUnitType() != other.getUnitType())
    return false;
  if (getAttributes() != other.getAttributes())
    return false;
  if (getTransformations() != other.getTransformations())
    return false;
  return true;
}

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

operator==() [2/3]

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());
}

operator==() [3/3]

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

inlineinherited

Disambiguate == and != by forwarding to CSGEngUnit (name/property-based comparison)

Definition at line 87 of file CSGSurfaceEngUnit.h.

{ return CSGEngUnit::operator==(other); }

releaseBase()

std::unique_ptr< CSGBase > CSG::CSGEngUnit::releaseBase ( )

protectedinherited

Transfer ownership of the internal CSGBase out of this unit.

Called once by CSGBase::expandEngUnit() to join the internal base into the parent. After this call _internal_base is null.

Returns

unique_ptr to the internal CSGBase

Definition at line 28 of file CSGEngUnit.C.

{
  return std::move(_internal_base);
}

setName()

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

inlineprotectedinherited

Definition at line 119 of file CSGSurface.h.

{ _name = name; }

Member Data Documentation

_apothem

const Real CSG::CSGNPolygonUnit::_apothem

private

Distance from the polygon center to the midpoint of each side.

Definition at line 126 of file CSGNPolygonUnit.h.

Referenced by clone(), CSGNPolygonUnit(), evaluateSurfaceEquationAtPoint(), expandUnit(), getApothem(), getAttributes(), getRadius(), and getSideLength().

_behavior

MooseEnum CSG::CSGEngUnit::_behavior {"SURFACE CELL UNIVERSE"}

protectedinherited

The basic CSG type this unit produces: "SURFACE", "CELL", or "UNIVERSE".

Definition at line 133 of file CSGEngUnit.h.

{"SURFACE CELL UNIVERSE"};

Referenced by CSG::CSGEngUnit::CSGEngUnit(), and CSG::CSGEngUnit::getBehavior().

_expanded_region

CSGRegion CSG::CSGSurfaceEngUnit::_expanded_region

protectedinherited

Stores the result of expandUnit(); EMPTY until then.

Definition at line 129 of file CSGSurfaceEngUnit.h.

Referenced by expandUnit(), and CSG::CSGSurfaceEngUnit::getExpandedRegion().

_internal_base

std::unique_ptr<CSGBase> CSG::CSGEngUnit::_internal_base

protectedinherited

CSGBase populated by expandUnit(); joined into the parent CSGBase by expandEngUnit()

Definition at line 130 of file CSGEngUnit.h.

Referenced by expandUnit(), CSG::CSGEngUnit::getBase(), CSG::CSGCellEngUnit::getExpandedCell(), CSG::CSGUniverseEngUnit::getExpandedUniverse(), and CSG::CSGEngUnit::releaseBase().

_n_sides

const int CSG::CSGNPolygonUnit::_n_sides

private

Number of sides of the regular polygon.

Definition at line 123 of file CSGNPolygonUnit.h.

Referenced by clone(), CSGNPolygonUnit(), evaluateSurfaceEquationAtPoint(), expandUnit(), getAttributes(), getNumSides(), getRadius(), and getSideLength().

_name

std::string CSG::CSGSurface::_name

protectedinherited

Name of surface.

Definition at line 122 of file CSGSurface.h.

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

_planes

std::vector<const CSGSurface *> CSG::CSGNPolygonUnit::_planes

private

Pointers to the expanded plane surfaces, populated during expandUnit()

Definition at line 129 of file CSGNPolygonUnit.h.

_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().

---

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

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