CSG::CSGSurfaceEngUnit Class Reference

CSGSurfaceEngUnit is an abstract base class for "engineering units" that can be used as surfaces in cell region definitions. More...

#include <CSGSurfaceEngUnit.h>

Inheritance diagram for CSG::CSGSurfaceEngUnit:

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
	CSGSurfaceEngUnit (const std::string &name)
	Construct a new CSGSurfaceEngUnit. More...
std::unordered_map< std::string, Real >	getCoeffs () const override
	Always throws – coefficients are not defined for a surface engineering unit. More...
Real	evaluateSurfaceEquationAtPoint (const Point &p) const override=0
	Evaluate the surface equation at the given point. More...
const std::string &	getName () const override
	Satisfy CSGEngUnit::getName() – resolved via CSGSurface::getName() More...
bool	isEngUnit () const override
	Engineering units report true so comparisons can skip the dynamic_cast fast path. More...
bool	operator== (const CSGSurfaceEngUnit &other) const
	Disambiguate == and != by forwarding to CSGEngUnit (name/property-based comparison) More...
bool	operator!= (const CSGSurfaceEngUnit &other) const
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const override
	Delegate to CSGSurface (CSGTransformationHelper) More...
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const override
	Delegate to CSGSurface (CSGTransformationHelper) 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...
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::string	getBehavior () const
	Get the behavior of this engineering unit (surface (i.e. More...
const std::string	getUnitType () const
	Get the type name of this engineering unit. More...
virtual std::unordered_map< std::string, AttributeVariant >	getAttributes () const =0
	Get the attributes that define this engineering unit. More...
bool	operator== (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are equal. More...
bool	operator!= (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are not equal. 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
void	expandUnit () override=0
	Create and add the concrete CSGSurface(s) in _internal_base. More...
CSGRegion	getExpandedRegion () const
	Return the CSGRegion formed by the expanded CSGSurfaces. More...
std::unique_ptr< CSGSurface >	clone () const override=0
	clone() is pure virtual – derived classes must implement More...
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...
CSGBase &	getBase ()
	Get the internal CSGBase owned by this engineering unit. More...
std::unique_ptr< CSGBase >	releaseBase ()
	Transfer ownership of the internal CSGBase out of this unit. More...
	FRIEND_TEST (CSGEngUnitTest, testSurfUnit)
	Friends for unit testing. 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)
	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
CSGRegion	_expanded_region
	Stores the result of expandUnit(); EMPTY until then. More...
std::string	_name
	Name of surface. More...
std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object. More...
std::unique_ptr< CSGBase >	_internal_base
	CSGBase populated by expandUnit(); joined into the parent CSGBase by expandEngUnit() More...
MooseEnum	_behavior {"SURFACE CELL UNIVERSE"}
	The basic CSG type this unit produces: "SURFACE", "CELL", or "UNIVERSE". More...

Friends
class	CSGBase

Detailed Description

CSGSurfaceEngUnit is an abstract base class for "engineering units" that can be used as surfaces in cell region definitions.

Derived classes define domain-specific surface attributes and implement expandUnit() and expandedRegion() methods to produce the equivalent representation using the basic CSGSurface components.

Derived classes must implement:

• expandUnit(): construct the equivalent CSGSurface(s) and CSGRegion using _internal_base (e.g., _internal_base->addSurface(...)). The created CSGRegion should be a non-empty region assigned to _expanded_region so it can be returned by getExpandedRegion(). CSGBase::expandEngUnit() joins _internal_base afterward.
• evaluateSurfaceEquationAtPoint(): must implement a method to be able to pass a value to CSGSurface::getHalfspaceFromPoint() which will inform wether a point is in the positive or negative "half-space" of this "surface."
• clone(): return a deep copy of the derived class.
• getAttributes(): return a map of domain-specific attribute name to value.

Definition at line 42 of file CSGSurfaceEngUnit.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

CSGSurfaceEngUnit()

CSG::CSGSurfaceEngUnit::CSGSurfaceEngUnit

(

const std::string &

name

)

Construct a new CSGSurfaceEngUnit.

Parameters

name	unique name of surface (will be preserved on the registered surface)

Definition at line 15 of file CSGSurfaceEngUnit.C.

  : CSGSurface(name), CSGEngUnit("SURFACE")
{
}

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.

Referenced by CSG::CSGBase::expandEngUnit().

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

clone()

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

overrideprotectedpure virtual

clone() is pure virtual – derived classes must implement

Implements CSG::CSGSurface.

Implemented in CSG::CSGNPolygonUnit.

evaluateSurfaceEquationAtPoint()

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

overridepure virtual

Evaluate the surface equation at the given point.

Derived classes must implement this to allow callers to determine whether a point lies in the negative or positive half-space of the engineering unit without requiring prior expansion.

Parameters

p	point to evaluate

Returns

negative value if the point is in the negative half-space, positive if in the positive half-space, zero if on the surface

Implements CSG::CSGSurface.

Implemented in CSG::CSGNPolygonUnit.

expandUnit()

void CSG::CSGSurfaceEngUnit::expandUnit ( )

overrideprotectedpure virtual

Create and add the concrete CSGSurface(s) in _internal_base.

Called exclusively by CSGBase. The implementation must:

1. Construct the concrete surface (e.g., std::make_unique<CSGZCylinder>(...))
2. Add it via _internal_base->addSurface(std::move(surf)).
3. Assign _expanded_region from the resulting surface half-spaces.

Implements CSG::CSGEngUnit.

Implemented in CSG::CSGNPolygonUnit.

Referenced by CSG::CSGBase::expandEngUnit().

FRIEND_TEST() [1/6]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [2/6]

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

protectedinherited

FRIEND_TEST() [3/6]

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

protectedinherited

FRIEND_TEST() [4/6]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [5/6]

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

protectedinherited

FRIEND_TEST() [6/6]

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

protected

Friends for unit testing.

getAttributes()

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

pure virtualinherited

Get the attributes that define this engineering unit.

Returns a map of domain-specific parameter names to their values, describing the EngUnit in meaningful engineering terms.

Returns

map of attribute name to AttributeVariant value

Implemented in CSG::CSGNPolygonUnit.

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

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.

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

{ return _behavior; }

getCoeffs()

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

overridevirtual

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

protected

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

inlineoverridevirtual

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

Implements CSG::CSGEngUnit.

Definition at line 81 of file CSGSurfaceEngUnit.h.

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

{ return CSGSurface::getName(); }

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.

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

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

getTransformations()

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

inlineoverridevirtual

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

inlineoverridevirtual

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.

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

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.

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

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

isEngUnit()

bool CSG::CSGSurfaceEngUnit::isEngUnit ( ) const

inlineoverridevirtual

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.

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

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

inline

Definition at line 88 of file CSGSurfaceEngUnit.h.

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

operator!=() [2/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.

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

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

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

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

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

operator==() [2/3]

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

inline

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

Definition at line 87 of file CSGSurfaceEngUnit.h.

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

operator==() [3/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());
}

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

Friends And Related Function Documentation

CSGBase

friend class CSGBase

friend

Definition at line 133 of file CSGSurfaceEngUnit.h.

Member Data Documentation

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

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

_expanded_region

CSGRegion CSG::CSGSurfaceEngUnit::_expanded_region

protected

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

Definition at line 129 of file CSGSurfaceEngUnit.h.

Referenced by CSG::CSGNPolygonUnit::expandUnit(), and 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 CSG::CSGNPolygonUnit::expandUnit(), CSG::CSGEngUnit::getBase(), CSG::CSGCellEngUnit::getExpandedCell(), CSG::CSGUniverseEngUnit::getExpandedUniverse(), and CSG::CSGEngUnit::releaseBase().

_name

std::string CSG::CSGSurface::_name

protectedinherited

Name of surface.

Definition at line 122 of file CSGSurface.h.

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

_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/CSGSurfaceEngUnit.h
• src/csg/CSGSurfaceEngUnit.C