CSG::CSGCellEngUnit Class Reference

CSGCellEngUnit is an abstract base class for "engineering units" that are cell-like. More...

#include <CSGCellEngUnit.h>

Inheritance diagram for CSG::CSGCellEngUnit:

Public Member Functions
const std::string &	getName () const override
	Satisfy CSGEngUnit::getName() (resolved via CSGCell::getName())
bool	isEngUnit () const override
	Engineering units report true so comparisons can skip the dynamic_cast fast path.
bool	operator== (const CSGCellEngUnit &other) const
	Disambiguate == and != by forwarding to CSGEngUnit (name/property-based comparison)
bool	operator!= (const CSGCellEngUnit &other) const
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const override
	Delegate to CSGCell (CSGTransformationHelper)
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const override
	Delegate to CSGCell (CSGTransformationHelper)
const std::string	getFillType () const
	Get the type of fill for the cell.
const CSGUniverse &	getFillUniverse () const
	Get the cell fill if fill type is UNIVERSE.
const std::string &	getFillMaterial () const
	Get the cell fill material name if fill fype is CSG_MATERIAL.
const CSGLattice &	getFillLattice () const
	Get the cell fill if fill type is LATTICE.
const std::string &	getFillName () const
	Get the name of the fill, regardless of its type.
const CSGRegion &	getRegion () const
	Get the cell region.
bool	operator== (const CSGCell &other) const
	Operator overload for checking if two CSGCell objects are equal.
bool	operator!= (const CSGCell &other) const
	Operator overload for checking if two CSGCell objects are not equal.
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.
virtual std::unordered_map< std::string, AttributeVariant >	getAttributes () const =0
	Get the attributes that define this engineering unit.
bool	operator== (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are equal.
bool	operator!= (const CSGEngUnit &other) const
	Operator overload for checking if two CSGEngUnit objects are not equal.

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
	CSGCellEngUnit (const std::string &name)
	Constructor for derived classes.
virtual std::unique_ptr< CSGCellEngUnit >	clone () const =0
	Create a deep copy of this engineering unit for use in a different CSGBase instance.
void	expandUnit () override=0
	Create the CSGCell and any other necessary components in _internal_base.
const CSGCell &	getExpandedCell () const
	Return the single cell in _internal_base's root, which IS the expanded cell.
void	setName (const std::string &name)
void	updateCellRegionSurfaces (std::map< std::string, std::reference_wrapper< const CSGSurface > > &identical_surface_refs)
	Update surface references of cell region based on map of input surface references.
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.
void	resetCellFill ()=delete
	Cell fill and region updates are not permitted on engineering units.
void	updateCellFill (const std::string &)=delete
void	updateCellFill (const CSGUniverse *)=delete
void	updateCellFill (const CSGLattice *)=delete
void	updateRegion (const CSGRegion &)=delete
	FRIEND_TEST (CSGCellTest, testSetName)
	Friends for unit testing.
	FRIEND_TEST (CSGCellTest, testUpdateRegion)
	FRIEND_TEST (CSGCellTest, testCellEquality)
	FRIEND_TEST (CSGCellTest, testUpdateFill)
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing.
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)
	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
std::string	_name
	Name of surface.
MooseEnum	_fill_type {"VOID CSG_MATERIAL UNIVERSE LATTICE"}
	An enum for type of fill for cell region.
std::string	_fill_name
	name of the fill object for CSG_MATERIAL fills
CSGRegion	_region
	Cell region, represented as a CSGRegion object.
const CSGUniverse *	_fill_universe
	Fill object if fill is CSGUniverse.
const CSGLattice *	_fill_lattice
	Fill object if fill is CSGLattice.
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".

Friends
class	CSGBase

Detailed Description

CSGCellEngUnit is an abstract base class for "engineering units" that are cell-like.

Derived classes define domain-specific attributes and implement expandUnit() to produce the equivalent CSGCell representation using basic CSG components.

Derived classes must implement:

• expandUnit(): populate _internal_base with the expanded cell and any supporting objects. Create surfaces via _internal_base->addSurface(...), any fill universes via _internal_base->createUniverse(...), and the cell via _internal_base->createCell(...) which puts the cell into the root automatically. Exactly one cell must be in the root. 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 CSGCellEngUnit.h.

Constructor & Destructor Documentation

CSGCellEngUnit()

CSG::CSGCellEngUnit::CSGCellEngUnit ( const std::string &  name )

protected

Constructor for derived classes.

Initializes the base CSGCell with a placeholder empty CSGRegion.

Parameters

name	name of the cell (will be preserved on the plain CSGCell after expansion)

Definition at line 17 of file CSGCellEngUnit.C.

  : CSGCell(name, CSGRegion()), CSGEngUnit("CELL")
{
}

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

virtual std::unique_ptr< CSGCellEngUnit > CSG::CSGCellEngUnit::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::CSGCellEngUnit::expandUnit ( )

overrideprotectedpure virtual

Create the CSGCell and any other necessary components in _internal_base.

Called exclusively by CSGBase. The implementation should:

1. Create any needed CSGSurfaces via _internal_base->addSurface(...)
2. Create a CSGRegion from those surfaces
3. Create any fill universe if necessary via _internal_base->createUniverse(...)
4. Register exactly one CSGCell via _internal_base->createCell(...) to go into root.

Implements CSG::CSGEngUnit.

FRIEND_TEST() [1/7]

CSG::CSGCell::FRIEND_TEST ( CSGCellTest  , testCellEquality    )

protectedinherited

FRIEND_TEST() [2/7]

CSG::CSGCell::FRIEND_TEST ( CSGCellTest  , testSetName    )

protectedinherited

Friends for unit testing.

FRIEND_TEST() [3/7]

CSG::CSGCell::FRIEND_TEST ( CSGCellTest  , testUpdateFill    )

protectedinherited

FRIEND_TEST() [4/7]

CSG::CSGCell::FRIEND_TEST ( CSGCellTest  , testUpdateRegion    )

protectedinherited

FRIEND_TEST() [5/7]

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

protectedinherited

FRIEND_TEST() [6/7]

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

protectedinherited

FRIEND_TEST() [7/7]

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

protectedinherited

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.

{ return _behavior; }

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

getExpandedCell()

const CSGCell & CSG::CSGCellEngUnit::getExpandedCell ( ) const

protected

Return the single cell in _internal_base's root, which IS the expanded cell.

Enforces that exactly one cell is in the root (errors otherwise). Valid after expandUnit() has been called. Not valid after CSGBase::expandEngUnit() has consumed the internal base.

Returns

const reference to the expanded CSGCell

Definition at line 23 of file CSGCellEngUnit.C.

{
  // must contain exactly one cell in the root universe to be considered a correct implementation
  // and be expanded properly. Additional cells can exist in _internal_base through universe/cell
  // nesting.
  const auto & cells = _internal_base->getRootUniverse().getAllCells();
  if (cells.size() == 0)
    mooseError("The root universe of CSGCellEngUnit ",
               getName(),
               " contains no cells. ",
               "Either getExpandedCell() was called before expandUnit() or expandUnit() is not "
               "implemented correctly");
  if (cells.size() > 1)
    mooseError("CSGCellEngUnit '",
               getName(),
               "' expandUnit() must create exactly one cell in _internal_base's root universe "
               "(found ",
               cells.size(),
               ").");
  // Check that all universes and cells in _internal_base are reachable from root.
  if (!_internal_base->areUniversesLinked())
    mooseError("CSGCellEngUnit '",
               getName(),
               "' of type '",
               getUnitType(),
               "' contains unlinked universes or cells. All objects created in expandUnit() must "
               "be reachable from root. Check implementation of expandUnit().");
 
  return cells[0];
}

getFillLattice()

const CSGLattice & CSG::CSGCell::getFillLattice ( ) const

inherited

Get the cell fill if fill type is LATTICE.

Returns

Reference to CSGLattice fill

Definition at line 77 of file CSGCell.C.

{
  if (getFillType() != "LATTICE")
    mooseError("Cell '" + getName() + "' has " + getFillType() + " fill, not LATTICE.");
  else
    return *_fill_lattice;
}

Referenced by CSG::CSGBase::addCellToList(), and CSG::CSGCell::operator==().

getFillMaterial()

const std::string & CSG::CSGCell::getFillMaterial ( ) const

inherited

Get the cell fill material name if fill fype is CSG_MATERIAL.

Returns

name of the cell's CSG material fill

Definition at line 68 of file CSGCell.C.

{
  if (getFillType() != "CSG_MATERIAL")
    mooseError("Cell '" + getName() + "' has " + getFillType() + " fill, not CSG_MATERIAL.");
  else
    return _fill_name;
}

Referenced by CSG::CSGBase::addCellToList(), and CSG::CSGCell::operator==().

getFillName()

const std::string & CSG::CSGCell::getFillName ( ) const

inherited

Get the name of the fill, regardless of its type.

Returns

std::string fill name

Definition at line 48 of file CSGCell.C.

{
  if (getFillType() == "UNIVERSE")
    return _fill_universe->getName();
  else if (getFillType() == "LATTICE")
    return _fill_lattice->getName();
  else
    return _fill_name;
}

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

getFillType()

const std::string CSG::CSGCell::getFillType ( ) const

inlineinherited

Get the type of fill for the cell.

Returns

fill type

Definition at line 77 of file CSGCell.h.

{ return _fill_type; }

Referenced by CSG::CSGBase::addCellToList(), CSG::CSGCell::getFillLattice(), CSG::CSGCell::getFillMaterial(), CSG::CSGCell::getFillName(), CSG::CSGCell::getFillUniverse(), CSG::CSGCell::operator==(), and CSG::CSGBase::replaceUniverseRefs().

getFillUniverse()

const CSGUniverse & CSG::CSGCell::getFillUniverse ( ) const

inherited

Get the cell fill if fill type is UNIVERSE.

Returns

Reference to CSGUniverse fill

Definition at line 59 of file CSGCell.C.

{
  if (getFillType() != "UNIVERSE")
    mooseError("Cell '" + getName() + "' has " + getFillType() + " fill, not UNIVERSE.");
  else
    return *_fill_universe;
}

Referenced by CSG::CSGBase::addCellToList(), CSG::CSGCell::operator==(), and CSG::CSGBase::replaceUniverseRefs().

getName()

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

inlineoverridevirtual

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

Implements CSG::CSGEngUnit.

Definition at line 42 of file CSGCellEngUnit.h.

{ return CSGCell::getName(); }

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

getRegion()

const CSGRegion & CSG::CSGCell::getRegion ( ) const

inlineinherited

Get the cell region.

Returns

const CSGRegion& region of the cell

Definition at line 119 of file CSGCell.h.

{ return _region; }

Referenced by CSG::CSGBase::addCellToList(), CSG::CSGCell::operator==(), and CSG::CSGBase::replaceSurfaceRefsWithRegion().

getTransformations()

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

inlineoverridevirtual

Delegate to CSGCell (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 52 of file CSGCellEngUnit.h.

  {
    return CSGCell::getTransformations();
  }

getTransformationsAsStrings()

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

inlineoverridevirtual

Delegate to CSGCell (CSGTransformationHelper)

Implements CSG::CSGEngUnit.

Definition at line 59 of file CSGCellEngUnit.h.

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

isEngUnit()

bool CSG::CSGCellEngUnit::isEngUnit ( ) const

inlineoverridevirtual

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

Reimplemented from CSG::CSGCell.

Definition at line 45 of file CSGCellEngUnit.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::CSGCell::operator!= ( const CSGCell &  other ) const

inherited

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

Definition at line 159 of file CSGCell.C.

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

operator!=() [2/3]

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

inline

Definition at line 49 of file CSGCellEngUnit.h.

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

operator!=() [3/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 operator!=(), CSG::CSGSurfaceEngUnit::operator!=(), and CSG::CSGUniverseEngUnit::operator!=().

operator==() [1/3]

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

inherited

Operator overload for checking if two CSGCell objects are equal.

Definition at line 126 of file CSGCell.C.

{
  // If both objects are engineering units, delegate to CSGEngUnit::operator==. The
  // isEngUnit() check keeps the common plain-cell 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 cell
  }
 
  const auto name_eq = this->getName() == other.getName();
  const auto region_eq = this->getRegion() == other.getRegion();
  const auto fill_type_eq =
      (this->getFillType() == other.getFillType()) && (this->getFillName() == other.getFillName());
  const auto transformations_eq = this->getTransformations() == other.getTransformations();
  if (name_eq && region_eq && fill_type_eq && transformations_eq)
  {
    if (this->getFillType() == "CSG_MATERIAL")
      return this->getFillMaterial() == other.getFillMaterial();
    else if (this->getFillType() == "UNIVERSE")
      return this->getFillUniverse() == other.getFillUniverse();
    else if (this->getFillType() == "LATTICE")
      return this->getFillLattice() == other.getFillLattice();
    else
      return true;
  }
  else
    return false;
}

operator==() [2/3]

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

inline

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

Definition at line 48 of file CSGCellEngUnit.h.

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

operator==() [3/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 operator==(), CSG::CSGSurfaceEngUnit::operator==(), and CSG::CSGUniverseEngUnit::operator==().

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

resetCellFill()

void CSG::CSGCellEngUnit::resetCellFill ( )

protecteddelete

Cell fill and region updates are not permitted on engineering units.

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

setName()

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

inlineprotectedinherited

Definition at line 147 of file CSGCell.h.

{ _name = name; }

updateCellFill() [1/3]

void CSG::CSGCellEngUnit::updateCellFill ( const CSGLattice *  )

protecteddelete

updateCellFill() [2/3]

void CSG::CSGCellEngUnit::updateCellFill ( const CSGUniverse *  )

protecteddelete

updateCellFill() [3/3]

void CSG::CSGCellEngUnit::updateCellFill ( const std::string &  )

protecteddelete

updateCellRegionSurfaces()

void CSG::CSGCell::updateCellRegionSurfaces ( std::map< std::string, std::reference_wrapper< const CSGSurface > > &  identical_surface_refs )

protectedinherited

Update surface references of cell region based on map of input surface references.

Parameters

identical_surface_refs

map of surface name to surface references that region should be defined with

Definition at line 119 of file CSGCell.C.

{
  _region.updateSurfaceReferences(identical_surface_refs);
}

updateRegion()

void CSG::CSGCellEngUnit::updateRegion ( const CSGRegion &  )

protecteddelete

Friends And Related Symbol Documentation

CSGBase

friend class CSGBase

friend

Definition at line 117 of file CSGCellEngUnit.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.

{"SURFACE CELL UNIVERSE"};

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

_fill_lattice

const CSGLattice* CSG::CSGCell::_fill_lattice

protectedinherited

Fill object if fill is CSGLattice.

Definition at line 199 of file CSGCell.h.

Referenced by CSG::CSGCell::getFillLattice(), CSG::CSGCell::getFillName(), CSG::CSGCell::resetCellFill(), and CSG::CSGCell::updateCellFill().

_fill_name

std::string CSG::CSGCell::_fill_name

protectedinherited

name of the fill object for CSG_MATERIAL fills

Definition at line 190 of file CSGCell.h.

Referenced by CSG::CSGCell::getFillMaterial(), CSG::CSGCell::getFillName(), CSG::CSGCell::resetCellFill(), and CSG::CSGCell::updateCellFill().

_fill_type

MooseEnum CSG::CSGCell::_fill_type {"VOID CSG_MATERIAL UNIVERSE LATTICE"}

protectedinherited

An enum for type of fill for cell region.

Definition at line 187 of file CSGCell.h.

{"VOID CSG_MATERIAL UNIVERSE LATTICE"};

Referenced by CSG::CSGCell::CSGCell(), CSG::CSGCell::CSGCell(), CSG::CSGCell::CSGCell(), CSG::CSGCell::CSGCell(), CSG::CSGCell::getFillType(), CSG::CSGCell::resetCellFill(), CSG::CSGCell::updateCellFill(), CSG::CSGCell::updateCellFill(), and CSG::CSGCell::updateCellFill().

_fill_universe

const CSGUniverse* CSG::CSGCell::_fill_universe

protectedinherited

Fill object if fill is CSGUniverse.

Definition at line 196 of file CSGCell.h.

Referenced by CSG::CSGCell::getFillName(), CSG::CSGCell::getFillUniverse(), CSG::CSGCell::resetCellFill(), and CSG::CSGCell::updateCellFill().

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

_name

std::string CSG::CSGCell::_name

protectedinherited

Name of surface.

Definition at line 184 of file CSGCell.h.

Referenced by CSG::CSGCell::getName(), and CSG::CSGCell::setName().

_region

CSGRegion CSG::CSGCell::_region

protectedinherited

Cell region, represented as a CSGRegion object.

Definition at line 193 of file CSGCell.h.

Referenced by CSG::CSGCell::getRegion(), CSG::CSGCell::updateCellRegionSurfaces(), and CSG::CSGCell::updateRegion().

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