CSG::CSGUniverseEngUnit Class Reference

CSGUniverseEngUnit is an abstract base class for "engineering units" that are universe-like. More...

#include <CSGUniverseEngUnit.h>

Inheritance diagram for CSG::CSGUniverseEngUnit:

Public Member Functions
const std::string &	getName () const override
	Satisfy CSGEngUnit::getName() (resolved via CSGUniverse::getName()) More...
bool	isEngUnit () const override
	Engineering units report true so comparisons can skip the dynamic_cast fast path. More...
bool	operator== (const CSGUniverseEngUnit &other) const
	Disambiguate == and != by forwarding to CSGEngUnit (name/property-based comparison) More...
bool	operator!= (const CSGUniverseEngUnit &other) const
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const override
	Delegate to CSGUniverse (CSGTransformationHelper) More...
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const override
	Delegate to CSGUniverse (CSGTransformationHelper) More...
const CSGCell &	getCell (const std::string &name)
	Get the CSGCell object by name. More...
bool	hasCell (const std::string &name) const
	check if cell of provided name is present in universe More...
const std::vector< std::reference_wrapper< const CSGCell > > &	getAllCells () const
	Get list of the all cells in the universe. More...
bool	isRoot () const
	return true if the universe is the root universe More...
bool	operator== (const CSGUniverse &other) const
	Operator overload for checking if two CSGUniverse objects are equal. More...
bool	operator!= (const CSGUniverse &other) const
	Operator overload for checking if two CSGUniverse 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
	CSGUniverseEngUnit (const std::string &name, bool is_root=false)
	Constructor for derived classes. More...
virtual std::unique_ptr< CSGUniverseEngUnit >	clone () const =0
	Create a deep copy of this engineering unit for use in a different CSGBase instance. More...
void	expandUnit () override=0
	Populate _internal_base with the CSGUniverse and any supporting objects. More...
const CSGUniverse &	getExpandedUniverse () const
	Return the root universe of _internal_base, which IS the expanded universe. More...
void	removeCell (const std::string &name)
	remove a cell of the specified name from the universe More...
void	removeAllCells ()
	remove all cells from the universe 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...
void	addCell (const CSGCell &)=delete
	addCell updates are not permitted on engineering units. More...
	FRIEND_TEST (CSGUniverseTest, testGetCell)
	Friends for unit testing. More...
	FRIEND_TEST (CSGUniverseTest, testAddCell)
	FRIEND_TEST (CSGUniverseTest, testRemoveCell)
	FRIEND_TEST (CSGUniverseTest, testRemoveAllCells)
	FRIEND_TEST (CSGUniverseTest, testSetName)
	FRIEND_TEST (CSGUniverseTest, testUniverseEquality)
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing. More...
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)
	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
std::string	_name
	Name of universe. More...
std::vector< std::reference_wrapper< const CSGCell > >	_cells
	list of references to cells in universe More...
bool	_is_root
	whether or not this universe is the root universe 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

CSGUniverseEngUnit is an abstract base class for "engineering units" that are universe-like.

Derived classes define domain-specific attributes and implement expandUnit() to produce the equivalent CSGUniverse representation, along with all supporting surfaces and cells.

Derived classes must implement:

• expandUnit(): populate _internal_base: create cells via _internal_base->createCell(...) (they go to the root automatically), create any non-root fill universes via _internal_base->createUniverse(...), and rename the root with _internal_base->renameRootUniverse("name"). The root IS the expanded universe. CSGBase::expandEngUnit() joins _internal_base via joinOtherBase() afterward.
• clone(): return a deep copy of the derived class.
• getAttributes(): return a map of domain-specific attribute name to value.

Definition at line 38 of file CSGUniverseEngUnit.h.

Constructor & Destructor Documentation

CSGUniverseEngUnit()

CSG::CSGUniverseEngUnit::CSGUniverseEngUnit ( const std::string &  name, bool  is_root = false  )

protected

Constructor for derived classes.

Parameters

name	unique name of the universe (will be preserved on the plain CSGUniverse)
is_root	true if this is the root universe (default false)

Definition at line 16 of file CSGUniverseEngUnit.C.

  : CSGUniverse(name, is_root), CSGEngUnit("UNIVERSE")
{
}

Member Function Documentation

addCell()

void CSG::CSGUniverseEngUnit::addCell ( const CSGCell &  )

protecteddelete

addCell updates are not permitted on engineering units.

The geometry is defined by the derived class and produced only via expandUnit().

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

virtual std::unique_ptr<CSGUniverseEngUnit> CSG::CSGUniverseEngUnit::clone ( ) const

protectedpure virtual

Create a deep copy of this engineering unit for use in a different CSGBase instance.

Derived classes must implement this and return a fully-constructed copy with the same attributes.

Returns

unique_ptr to a fresh copy of this engineering unit

expandUnit()

void CSG::CSGUniverseEngUnit::expandUnit ( )

overrideprotectedpure virtual

Populate _internal_base with the CSGUniverse and any supporting objects.

Called exclusively by CSGBase. The root universe of _internal_base represents this engineering unit's expanded universe. The implementation should:

1. Create any needed surfaces via _internal_base->addSurface(...).
2. Create cells via _internal_base->createCell(...) (they go to the root automatically).
3. Create any non-root fill universes via _internal_base->createUniverse(...).
4. Rename the root with _internal_base->renameRootUniverse("desired_name") if needed.

Implements CSG::CSGEngUnit.

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

FRIEND_TEST() [1/9]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [2/9]

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

protectedinherited

FRIEND_TEST() [3/9]

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

protectedinherited

FRIEND_TEST() [4/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testGetCell    )

protectedinherited

Friends for unit testing.

FRIEND_TEST() [5/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testAddCell    )

protectedinherited

FRIEND_TEST() [6/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testRemoveCell    )

protectedinherited

FRIEND_TEST() [7/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testRemoveAllCells    )

protectedinherited

FRIEND_TEST() [8/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testSetName    )

protectedinherited

FRIEND_TEST() [9/9]

CSG::CSGUniverse::FRIEND_TEST ( CSGUniverseTest  , testUniverseEquality    )

protectedinherited

getAllCells()

const std::vector<std::reference_wrapper<const CSGCell> >& CSG::CSGUniverse::getAllCells ( ) const

inlineinherited

Get list of the all cells in the universe.

Returns

list of pointers to cells in universe

Definition at line 73 of file CSGUniverse.h.

Referenced by CSG::CSGBase::addUniverseToList(), CSG::CSGBase::CSGBase(), CSG::CSGBase::getLinkedUniverses(), CSG::CSGUniverse::operator==(), and CSG::CSGBase::replaceCellRefs().

{ return _cells; }

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

getCell()

const CSGCell & CSG::CSGUniverse::getCell ( const std::string &  name )

inherited

Get the CSGCell object by name.

Parameters

name	name of cell

Returns

reference to the cell of the specified name in this universe

Definition at line 40 of file CSGUniverse.C.

{
  if (!hasCell(name))
    mooseError("Cell with name " + name + " does not exist in universe " + _name + ".");
  for (const CSGCell & cell : _cells)
    if (cell.getName() == name)
      return cell;
  mooseError("Should not reach here.");
}

getExpandedUniverse()

const CSGUniverse & CSG::CSGUniverseEngUnit::getExpandedUniverse ( ) const

protected

Return the root universe of _internal_base, which IS the expanded universe.

Valid after expandUnit() has populated _internal_base. Not valid after CSGBase::expandEngUnit() has run (the internal base is consumed by the join).

Returns

const reference to the root CSGUniverse of _internal_base

Definition at line 22 of file CSGUniverseEngUnit.C.

{
  // if root universe contains no cells, then it has not be expanded (or not implemented correctly)
  if (_internal_base->getRootUniverse().getAllCells().empty())
    mooseError("Root universe of ",
               getName(),
               " contains no cells. ",
               "Either getExpandedUniverse() has been called before expandUnit() or expandUnit() ",
               "is not implemented correctly.");

  // Check that all universes and cells created in _internal_base are reachable from the root.
  if (!_internal_base->areUniversesLinked())
    mooseError("CSGUniverseEngUnit '",
               getName(),
               "' of type '",
               getUnitType(),
               "' contains unlinked universes or cells. All objects created in expandUnit() must be"
               " reachable from the expanded root universe. Check implementation of expandUnit().");

  return _internal_base->getRootUniverse();
}

getName()

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

inlineoverridevirtual

Satisfy CSGEngUnit::getName() (resolved via CSGUniverse::getName())

Implements CSG::CSGEngUnit.

Definition at line 42 of file CSGUniverseEngUnit.h.

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

{ return CSGUniverse::getName(); }

getTransformations()

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

inlineoverridevirtual

Delegate to CSGUniverse (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 53 of file CSGUniverseEngUnit.h.

  {
    return CSGUniverse::getTransformations();
  }

getTransformationsAsStrings()

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

inlineoverridevirtual

Delegate to CSGUniverse (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 60 of file CSGUniverseEngUnit.h.

  {
    return CSGUniverse::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(), getExpandedUniverse(), and CSG::CSGEngUnit::operator==().

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

hasCell()

bool CSG::CSGUniverse::hasCell ( const std::string &  name ) const

inherited

check if cell of provided name is present in universe

Parameters

name	name of cell

Returns

true if cell of name is in universe, otherwise false

Definition at line 51 of file CSGUniverse.C.

Referenced by CSG::CSGUniverse::addCell(), CSG::CSGUniverse::getCell(), and CSG::CSGUniverse::removeCell().

{
  for (const CSGCell & cell : _cells)
    if (cell.getName() == name)
      return true;
  return false;
}

isEngUnit()

bool CSG::CSGUniverseEngUnit::isEngUnit ( ) const

inlineoverridevirtual

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

Reimplemented from CSG::CSGUniverse.

Definition at line 45 of file CSGUniverseEngUnit.h.

{ return true; }

isRoot()

bool CSG::CSGUniverse::isRoot ( ) const

inlineinherited

return true if the universe is the root universe

Returns

true / false

Definition at line 87 of file CSGUniverse.h.

{ return _is_root; }

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::CSGUniverseEngUnit::operator!= ( const CSGUniverseEngUnit &  other ) const

inline

Definition at line 49 of file CSGUniverseEngUnit.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!=(), operator!=(), and CSG::CSGSurfaceEngUnit::operator!=().

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

operator!=() [3/3]

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

inherited

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

Definition at line 104 of file CSGUniverse.C.

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

operator==() [1/3]

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

inline

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

Definition at line 48 of file CSGUniverseEngUnit.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 equal.

Definition at line 34 of file CSGEngUnit.C.

Referenced by CSG::CSGCellEngUnit::operator==(), operator==(), and CSG::CSGSurfaceEngUnit::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==() [3/3]

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

inherited

Operator overload for checking if two CSGUniverse objects are equal.

Definition at line 74 of file CSGUniverse.C.

{
  // If both objects are engineering units, delegate to CSGEngUnit::operator==. The
  // isEngUnit() check keeps the common plain-universe 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 universe
  }

  if ((this->getName() != other.getName()) ||
      (this->getTransformations() != other.getTransformations()))
    return false;
  const auto & all_cells = getAllCells();
  const auto & other_cells = other.getAllCells();
  const bool num_cells_eq = all_cells.size() == other_cells.size();
  if (num_cells_eq)
  {
    for (unsigned int i = 0; i < all_cells.size(); ++i)
      if (all_cells[i].get() != other_cells[i].get())
        return false;
    return true;
  }
  else
    return false;
}

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

removeAllCells()

void CSG::CSGUniverse::removeAllCells ( )

inlineprotectedinherited

remove all cells from the universe

Definition at line 124 of file CSGUniverse.h.

{ _cells.clear(); }

removeCell()

void CSG::CSGUniverse::removeCell ( const std::string &  name )

protectedinherited

remove a cell of the specified name from the universe

Parameters

name	name of cell to remove

Definition at line 60 of file CSGUniverse.C.

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

{
  if (!hasCell(name))
    mooseError("Cannot remove cell. Cell with name " + name + " does not exist in universe " +
               _name + ".");
  for (auto it = _cells.begin(); it != _cells.end(); ++it)
    if (it->get().getName() == name)
    {
      _cells.erase(it);
      break;
    }
}

setName()

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

inlineprotectedinherited

Definition at line 128 of file CSGUniverse.h.

{ _name = name; }

Friends And Related Function Documentation

CSGBase

friend class CSGBase

friend

Definition at line 113 of file CSGUniverseEngUnit.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().

_cells

std::vector<std::reference_wrapper<const CSGCell> > CSG::CSGUniverse::_cells

protectedinherited

list of references to cells in universe

Definition at line 134 of file CSGUniverse.h.

Referenced by CSG::CSGUniverse::addCell(), CSG::CSGUniverse::getAllCells(), CSG::CSGUniverse::getCell(), CSG::CSGUniverse::hasCell(), CSG::CSGUniverse::removeAllCells(), and CSG::CSGUniverse::removeCell().

_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(), getExpandedUniverse(), and CSG::CSGEngUnit::releaseBase().

_is_root

bool CSG::CSGUniverse::_is_root

protectedinherited

whether or not this universe is the root universe

Definition at line 137 of file CSGUniverse.h.

Referenced by CSG::CSGUniverse::isRoot().

_name

std::string CSG::CSGUniverse::_name

protectedinherited

Name of universe.

Definition at line 131 of file CSGUniverse.h.

Referenced by CSG::CSGUniverse::getCell(), CSG::CSGUniverse::getName(), CSG::CSGUniverse::removeCell(), and CSG::CSGUniverse::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/CSGUniverseEngUnit.h
• src/csg/CSGUniverseEngUnit.C