CSGBase creates an internal representation of a Constructive Solid Geometry (CSG) model. More...

#include <CSGBase.h>

Public Member Functions
	CSGBase ()
	Default constructor.

	CSGBase (const CSGBase &other_base)
	Copy constructor.

	~CSGBase ()
	Destructor.

std::unique_ptr< CSGBase >	clone () const
	Create a deep copy of this CSGBase instance.

const CSGSurface &	addSurface (std::unique_ptr< CSGSurface > surf)
	add a unique surface pointer to this base instance

void	deleteSurface (const CSGSurface &surface)
	Remove a Surface object passed in by reference from the stored surface list.

std::vector< std::reference_wrapper< const CSGSurface > >	getAllSurfaces () const
	Get all surface objects.

const CSGSurface &	getSurfaceByName (const std::string &name) const
	Get a Surface object by name.

bool	hasSurface (const std::string &name) const
	Check if a surface with given name exists in CSGBase object.

void	renameSurface (const CSGSurface &surface, const std::string &name)
	rename the specified surface

const CSGCell &	createCell (const std::string &name, const std::string &mat_name, const CSGRegion &region, const CSGUniverse *add_to_univ=nullptr)
	Create a Material Cell object.

const CSGCell &	createCell (const std::string &name, const CSGRegion &region, const CSGUniverse *add_to_univ=nullptr)
	Create a Void Cell object.

const CSGCell &	createCell (const std::string &name, const CSGUniverse &fill_univ, const CSGRegion &region, const CSGUniverse *add_to_univ=nullptr)
	Create a Universe Cell object.

const CSGCell &	createCell (const std::string &name, const CSGLattice &fill_lattice, const CSGRegion &region, const CSGUniverse *add_to_univ=nullptr)
	Create a Lattice Cell object.

void	deleteCell (const CSGCell &cell)
	Remove a Cell object passed in by reference from the stored cell list.

std::vector< std::reference_wrapper< const CSGCell > >	getAllCells () const
	Get all cell objects.

const CSGCell &	getCellByName (const std::string &name) const
	Get a Cell object by name.

bool	hasCell (const std::string &name) const
	Check if a cell with given name exists in CSGBase object.

void	renameCell (const CSGCell &cell, const std::string &name)
	rename the specified cell

void	updateCellRegion (const CSGCell &cell, const CSGRegion &region)
	change the region of the specified cell

void	resetCellFill (const CSGCell &cell)
	reset the fill of the specified cell to void

void	updateCellFill (const CSGCell &cell, const std::string &mat_name)
	change the fill of the specified cell to a material fill

void	updateCellFill (const CSGCell &cell, const CSGUniverse *univ)
	change the fill of the specified cell to a universe fill

void	updateCellFill (const CSGCell &cell, const CSGLattice *lattice)
	change the fill of the specified cell to a lattice fill

const CSGUniverse &	getRootUniverse () const
	Get the Root Universe object.

void	renameRootUniverse (const std::string &name)
	rename the root universe for this instance (default is ROOT_UNIVERSE)

void	renameUniverse (const CSGUniverse &universe, const std::string &name)
	rename the specified universe

const CSGUniverse &	createUniverse (const std::string &name)
	Create an empty Universe object.

const CSGUniverse &	createUniverse (const std::string &name, std::vector< std::reference_wrapper< const CSGCell > > &cells)
	Create a Universe object from list of cells.

void	deleteUniverse (const CSGUniverse &univ)
	Remove a Universe object passed in by reference from the stored universe list.

void	addCellToUniverse (const CSGUniverse &universe, const CSGCell &cell)
	Add a cell to an existing universe.

void	addCellsToUniverse (const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell > > &cells)
	Add a list of cells to an existing universe.

void	removeCellFromUniverse (const CSGUniverse &universe, const CSGCell &cell)
	Remove a cell from an existing universe.

void	removeCellsFromUniverse (const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell > > &cells)
	Remove a list of cells from an existing universe.

std::vector< std::reference_wrapper< const CSGUniverse > >	getAllUniverses () const
	Get all universe objects.

const CSGUniverse &	getUniverseByName (const std::string &name)
	Get a universe object by name.

bool	hasUniverse (const std::string &name) const
	Check if a universe with given name exists in CSGBase object.

template<typename LatticeType = CSGLattice>
const LatticeType &	addLattice (std::unique_ptr< LatticeType > lattice)
	add a unique lattice pointer to this base instance; universes that make the lattice must already be a part of this CSGBase instance.

void	deleteLattice (const CSGLattice &lattice)
	Remove a Lattice object passed in by reference from the stored lattice list.

void	setUniverseAtLatticeIndex (const CSGLattice &lattice, const CSGUniverse &universe, std::pair< int, int > index)
	set location in the lattice to be the provided universe

void	setLatticeUniverses (const CSGLattice &lattice, std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > &universes)
	Set provided universes as the layout of the lattice.

void	renameLattice (const CSGLattice &lattice, const std::string &name)
	rename the lattice

void	setLatticeOuter (const CSGLattice &lattice, const std::string &outer_name)
	Set the outer fill for the lattice to the material name provided.

void	setLatticeOuter (const CSGLattice &lattice, const CSGUniverse &outer_univ)
	Set the outer fill for the lattice to the universe provided.

void	resetLatticeOuter (const CSGLattice &lattice)
	reset the outer fill for the lattice to VOID

std::vector< std::reference_wrapper< const CSGLattice > >	getAllLattices () const
	Get all lattice objects.

template<typename LatticeType = CSGLattice>
const LatticeType &	getLatticeByName (const std::string &name)
	Get a lattice object of the specified type by name.

bool	hasLattice (const std::string &name) const
	Check if a lattice with given name exists in CSGBase object.

template<typename T >
const T &	addEngUnit (std::unique_ptr< T > unit, const CSGUniverse *add_to_univ=nullptr)
	Add an engineering unit (surface-, cell-, or universe-like object) to this CSGBase.

void	deleteEngUnit (const CSGEngUnit &unit)
	Remove an engineering unit passed in by reference from the stored engineering unit list.

template<typename EngUnitType = CSGEngUnit>
const EngUnitType &	getEngUnitByName (const std::string &name) const
	Get a engineering unit object of the specified type by name.

bool	hasEngUnit (const std::string &name) const
	Check if an engineeering unit with given name exists in CSGBase object.

void	renameEngUnit (const CSGEngUnit &unit, const std::string &name)
	Rename the specified engineering unit.

std::vector< std::reference_wrapper< const CSGEngUnit > >	getAllEngUnits () const
	Get all engineering units of all types in CSGBase.

std::vector< std::reference_wrapper< const CSGSurfaceEngUnit > >	getAllSurfaceEngUnits () const
	Get all surface-like engineering units in CSGBase.

std::vector< std::reference_wrapper< const CSGCellEngUnit > >	getAllCellEngUnits () const
	Get all cell-like engineering units in CSGBase.

std::vector< std::reference_wrapper< const CSGUniverseEngUnit > >	getAllUniverseEngUnits () const
	Get all universe-like engineering units.

CSGRegion	expandEngUnit (const CSGSurfaceEngUnit &unit)
	Expand a surface-like engineering unit into basic CSGSurface(s) and return the CSGRegion representing the EngUnit's geometry.

const CSGCell &	expandEngUnit (const CSGCellEngUnit &unit)
	Expand a cell-like engineering unit into a basic CSGCell.

const CSGUniverse &	expandEngUnit (const CSGUniverseEngUnit &unit)
	Expand a universe-like engineering unit into a basic CSGUniverse.

void	expandAllEngUnits ()
	Expand all registered engineering units into basic CSG objects.

bool	areCSGObjectsLinked () const
	Check whether all universes, cells, and surfaces in this CSGBase are reachable from the root universe through the cell/fill hierarchy.

void	joinOtherBase (std::unique_ptr< CSGBase > base, const bool ignore_identical_components)
	Join another CSGBase object to this one.

void	joinOtherBase (std::unique_ptr< CSGBase > base, const bool ignore_identical_components, const std::string &new_root_name_join)
	Join another CSGBase object to this one.

void	joinOtherBase (std::unique_ptr< CSGBase > base, const bool ignore_identical_components, const std::string &new_root_name_base, const std::string &new_root_name_join)
	Join another CSGBase object to this one.

nlohmann::json	generateOutput () const
	generate the JSON representation output for the CSG object

bool	operator== (const CSGBase &other) const
	Operator overload for checking if two CSGBase objects are equal.

bool	operator!= (const CSGBase &other) const
	Operator overload for checking if two CSGBase objects are not equal.

void	addTransformation (const CSGObjectVariant &csg_object, TransformationType type, const std::tuple< Real, Real, Real > &values)
	Apply a transformation to a CSG object.

void	addTransformation (const CSGEngUnit &unit, TransformationType type, const std::tuple< Real, Real, Real > &values)
	Apply a transformation to a CSGEngUnit object.

void	applyTranslation (const CSGObjectVariant &csg_object, const std::tuple< Real, Real, Real > &distances)
	Apply a translation to a CSG object in the specified x, y, and z directions.

void	applyTranslation (const CSGEngUnit &unit, const std::tuple< Real, Real, Real > &distances)
	Apply a translation to a CSGEngUnit object in the specified x, y, and z directions.

void	applyRotation (const CSGObjectVariant &csg_object, const std::tuple< Real, Real, Real > &angles)
	Apply a rotation to a CSG object using (phi, theta, psi) angle notation (in degrees).

void	applyRotation (const CSGEngUnit &unit, const std::tuple< Real, Real, Real > &angles)
	Apply a rotation to a CSG object using (phi, theta, psi) angle notation (in degrees).

void	applyAxisRotation (const CSGObjectVariant &csg_object, RotationAxisType axis, const Real angle)
	Apply a rotation to a CSG object about a specified axis (X, Y, Z).

void	applyAxisRotation (const CSGEngUnit &unit, RotationAxisType axis, const Real angle)
	Apply a rotation to a CSGEngUnit object about a specified axis (X, Y, Z).

void	applyScaling (const CSGObjectVariant &csg_object, const std::tuple< Real, Real, Real > &values)
	Scale a CSG object in the specified x, y, and z directions.

void	applyScaling (const CSGEngUnit &unit, const std::tuple< Real, Real, Real > &values)
	Scale a CSGEngUnit object in the specified x, y, and z directions.

Private Member Functions
CSGSurface &	getSurface (const std::string &name)
	Get a Surface object by name.

void	expandAllEngUnitsCycle (std::set< std::set< std::string > > &all_type_sets)
	Recursive implementation of expandAllEngUnits().

void	checkUniverseLinking () const
	Check universes linked to root universe match universes defined in _universe_list.

void	getLinkedCSGObjects (const CSGUniverse &univ, std::set< std::string > &linked_universe_names, std::set< std::string > &linked_cell_names, std::set< std::string > &linked_surface_names) const
	Recursive method to retrieve all universes, cells, and surfaces linked to current universe.

const CSGSurfaceList &	getSurfaceList () const
	Get a const reference to the CSGSurfaceList object.

CSGSurfaceList &	getSurfaceList ()
	Get a non-const reference to the CSGSurfaceList object.

const CSGCellList &	getCellList () const
	Get a const reference to the CSGCellList object.

CSGCellList &	getCellList ()
	Get a non-const reference to the CSGCellList object.

const CSGUniverseList &	getUniverseList () const
	Get a const reference to the CSGUniverseList object.

CSGUniverseList &	getUniverseList ()
	Get a non-const reference to the CSGUniverseList object.

const CSGLatticeList &	getLatticeList () const
	Get a const reference to the CSGLatticeList object.

CSGLatticeList &	getLatticeList ()
	Get the CSGLatticeList object.

void	updateIncomingCSGReferences (CSGBase &incoming_base)
	update references of incoming CSGbase to point to those of existing CSGBase object.

void	replaceSurfaceRefsByName (std::map< std::string, std::reference_wrapper< const CSGSurface > > &identical_surface_refs, CSGBase &base)
	update surface references of incoming CSGBase to point to those of existing CSGBase object based on CSGSurface name.

void	replaceCellRefsByName (std::map< std::string, std::reference_wrapper< const CSGCell > > &identical_cell_refs, CSGBase &base)
	update cell references of incoming CSGbase to point to those of existing CSGBase object based on CSGCell name.

void	replaceUniverseRefsByName (std::map< std::string, std::reference_wrapper< const CSGUniverse > > &identical_universe_refs, CSGBase &base)
	update universe references of incoming CSGbase to point to those of existing CSGBase object based on CSGUniverse name.

void	replaceLatticeRefsByName (std::map< std::string, std::reference_wrapper< const CSGLattice > > &identical_lattice_refs, CSGBase &base)
	update lattice references of incoming CSGbase to point to those of existing CSGBase object based on CSGLattice name.

const CSGEngUnitList &	getEngUnitList () const
	Get a const reference to the CSGEngUnitList object.

void	joinSurfaceList (CSGSurfaceList &surf_list, const bool ignore_identical_surfaces)
	join a separate CSGSurfaceList object to this one

void	joinCellList (CSGCellList &cell_list, const bool ignore_identical_cells)
	join a separate CSGCellList object to this one

void	joinLatticeList (CSGLatticeList &lattice_list, const bool ignore_identical_lattices)
	join a separate CSGLatticeList object to this one

void	joinUniverseList (CSGUniverseList &univ_list, const bool ignore_identical_universes)
	join a separate CSGUniverseList object to this one; root universes from univ_list will be combined into this root universe

void	joinUniverseList (CSGUniverseList &univ_list, const bool ignore_identical_universes, const std::string &new_root_name_incoming)
	join a separate CSGUniverseList object to this one; the incoming root universe will be moved to a new universe of the new name specified.

void	joinUniverseList (CSGUniverseList &univ_list, const bool ignore_identical_universes, const std::string &new_root_name_base, const std::string &new_root_name_incoming)
	join a separate CSGUniverseList object to this one; both this root universe and the incoming root universe will be maintained as separate universes of the specified names.

void	rebuildEngUnitList ()
	rebuilds the list of raw pointers to engineering units by iterating through the surface, cell, and universe lists.

void	replaceUniverseRefs (const CSGUniverse &old_univ, const CSGUniverse &new_univ)
	Replace all cell fills and lattice elements/outers referencing old_univ with new_univ.

void	replaceCellRefs (const CSGCell &old_cell, const CSGCell &new_cell)
	Replace all old_cell references with new_cell across all universes in the base.

void	replaceSurfaceRefsWithRegion (const CSGSurface &old_surf, const CSGRegion &sub_region)
	Replace all region occurrences of old_surf with the tokens from sub_region across all cells in the base.

void	checkRegionSurfaces (const CSGRegion &region) const
	check that surfaces used in this region are a part of this CSGBase instance

bool	checkSurfaceInBase (const CSGSurface &surface) const
	check that surface being accessed is a part of this CSGBase instance

bool	checkCellInBase (const CSGCell &cell) const
	check that cell being accessed is a part of this CSGBase instance

bool	checkEngUnitInBase (const CSGEngUnit &unit) const
	check that engineering unit being accessed is a part of this CSGBase instance

bool	checkUniverseInBase (const CSGUniverse &universe) const
	check that universe being accessed is a part of this CSGBase instance

bool	checkLatticeInBase (const CSGLattice &lattice) const
	check that lattice being accessed is a part of this CSGBase instance

void	prepareSurfaceDeletion (const CSGSurface &surface) const
	error if surface is referenced in any cell region

void	prepareCellDeletion (const CSGCell &cell)
	warn and remove cell from any universe that contains it

void	prepareUniverseDeletion (const CSGUniverse &universe) const
	error if universe is the root, used in any lattice, or used as a cell fill

const CSGSurfaceEngUnit *	surfaceToEngUnit (const CSGSurface &surf) const
	Returns the CSGSurfaceEngUnit pointer if surf is an eng unit, nullptr otherwise.

const CSGCellEngUnit *	cellToEngUnit (const CSGCell &cell) const
	Returns the CSGCellEngUnit pointer if cell is an eng unit, nullptr otherwise.

const CSGUniverseEngUnit *	universeToEngUnit (const CSGUniverse &univ) const
	Returns the CSGUniverseEngUnit pointer if univ is an eng unit, nullptr otherwise.

const CSGCell &	addCellToList (const CSGCell &cell)
	Add a new cell to the cell list based on a cell reference.

const CSGUniverse &	addUniverseToList (const CSGUniverse &univ)
	Add a new universe to the universe list based on a universe reference.

const CSGLattice &	addLatticeToList (const CSGLattice &lattice)
	Add a new lattice to the lattice list based on a lattice reference.


	FRIEND_TEST (CSGBaseTest, testCheckRegionSurfaces)
	Friends for unit testing.

	FRIEND_TEST (CSGBaseTest, testAddGetSurface)

	FRIEND_TEST (CSGBaseTest, testUniverseLinking)

	FRIEND_TEST (CSGBaseTest, testEngUnitLinking)

	FRIEND_TEST (CSGBaseTest, testCellEngUnitAddErrors)

	FRIEND_TEST (CSGBaseTest, testUnivEngUnitAddErrors)

Private Attributes
CSGSurfaceList	_surface_list
	List of surfaces associated with CSG object.

CSGCellList	_cell_list
	List of cells associated with CSG object.

CSGUniverseList	_universe_list
	List of universes associated with CSG object.

CSGLatticeList	_lattice_list
	List of lattices associated with CSG object.

CSGEngUnitList	_eng_unit_list
	Container for all associated engineering units.

Detailed Description

CSGBase creates an internal representation of a Constructive Solid Geometry (CSG) model.

Definition at line 53 of file CSGBase.h.

Constructor & Destructor Documentation

◆ CSGBase() [1/2]

CSG::CSGBase::CSGBase ( )

Default constructor.

Definition at line 17 of file CSGBase.C.

  : _surface_list(CSGSurfaceList()),
    _cell_list(CSGCellList()),
    _universe_list(CSGUniverseList()),
    _lattice_list(CSGLatticeList())
{
}

◆ CSGBase() [2/2]

CSG::CSGBase::CSGBase ( const CSGBase & other_base )

Copy constructor.

Definition at line 25 of file CSGBase.C.

  : _surface_list(other_base.getSurfaceList()),
    _cell_list(CSGCellList()),
    _universe_list(CSGUniverseList()),
    _lattice_list(CSGLatticeList())
{
  // Add all engineering units first so the recursive addCellToList / addUniverseToList calls
  // below can find them via hasCell() / hasUniverse() and return early without erroring.
  // Cell engineering units do not have universes and universe engineering units do not contain
  // cells in the same way that the plain objects do, so we do not need to worry about recursion.
 
  // Bypass addCellToList because it doesn't properly handle engineering units and also bypass
  // addEngUnit for cells to avoid erroneously adding it to the root universe if it is not
  // necessary.
  for (const auto & eng_unit : other_base.getAllCellEngUnits())
    _cell_list.addCell(eng_unit.get().clone());
 
  for (const auto & eng_unit : other_base.getAllUniverseEngUnits())
    addEngUnit(eng_unit.get().clone());
 
  // Iterate through all non-eng unit cell references from the other CSGBase instance and
  // create new CSGCell pointers based on these references. This is done
  // recursively to properly handle cells with universe fills.
  for (const auto & [name, cell] : other_base.getCellList().getCellListMap())
    if (!cellToEngUnit(*cell))
      addCellToList(*cell);
 
  // Link all cells in other_base root universe to current root universe
  for (auto & root_cell : other_base.getRootUniverse().getAllCells())
  {
    const auto & list_cell = _cell_list.getCell(root_cell.get().getName());
    addCellToUniverse(getRootUniverse(), list_cell);
  }
 
  // Iterate through all non-eng unit universe references from the other CSGBase instance and
  // create new CSGUniverse pointers based on these references. This is done in case
  // any universe exist in the universe list that are not connected to the cell list.
  for (const auto & [name, univ] : other_base.getUniverseList().getUniverseListMap())
    if (!universeToEngUnit(*univ))
      addUniverseToList(*univ);
 
  // Iterate through all lattice references from the other CSGBase instance and
  // create new CSGLattice pointers based on these references.
  for (const auto & [name, lattice] : other_base.getLatticeList().getLatticeListMap())
    addLatticeToList(*lattice);
 
  // Rebuild the eng unit index from the now-complete surface, cell, and universe lists.
  rebuildEngUnitList();
}

◆ ~CSGBase()

CSG::CSGBase::~CSGBase ( )

Destructor.

Definition at line 75 of file CSGBase.C.

75{}

Member Function Documentation

◆ addCellsToUniverse()

void CSG::CSGBase::addCellsToUniverse	(	const CSGUniverse &	universe,
		std::vector< std::reference_wrapper< const CSGCell > > &	cells
	)

Add a list of cells to an existing universe.

Parameters

universe	universe to which to add the cells
cells	list of references to cells to add

Definition at line 547 of file CSGBase.C.

{
  for (auto & c : cells)
    addCellToUniverse(universe, c);
}

◆ addCellToList()

const CSGCell & CSG::CSGBase::addCellToList ( const CSGCell & cell )

private

Add a new cell to the cell list based on a cell reference.

This method is called by the copy constructor of CSGBase

Parameters

cell	reference to CSGCell that should be added to cell list

Definition at line 136 of file CSGBase.C.

{
  // If cell has already been created, we just return a reference to it
  const auto name = cell.getName();
  if (_cell_list.hasCell(name))
    return _cell_list.getCell(name);
 
  // Engineering unit cells must be registered via addEngUnit(), not addCellToList()
  if (cellToEngUnit(cell))
    mooseError("Cell '",
               name,
               "' is a CSGCellEngUnit and must be added via addEngUnit(), not addCellToList().");
 
  // Otherwise if the cell has material or void cell, we can create it directly
  const auto fill_type = cell.getFillType();
  const auto region = cell.getRegion();
  if (fill_type == "VOID")
    return _cell_list.addVoidCell(name, region);
  else if (fill_type == "CSG_MATERIAL")
  {
    const auto mat_name = cell.getFillMaterial();
    return _cell_list.addMaterialCell(name, mat_name, region);
  }
  else if (fill_type == "LATTICE")
  {
    // add lattice recursively to capture all linked universes in the lattice
    const CSGLattice & lattice = addLatticeToList(cell.getFillLattice());
    return _cell_list.addLatticeCell(name, lattice, region);
  }
  // Otherwise if the cell has a universe fill, we need to recursively define
  // all linked universes and cells first before defining this cell
  else if (fill_type == "UNIVERSE")
  {
    const auto & univ = addUniverseToList(cell.getFillUniverse());
    return _cell_list.addUniverseCell(name, univ, region);
  }
  else
    mooseError("Cell " + name + " has unrecognized fill type " + fill_type);
}

Referenced by CSGBase().

◆ addCellToUniverse()

void CSG::CSGBase::addCellToUniverse	(	const CSGUniverse &	universe,
		const CSGCell &	cell
	)

Add a cell to an existing universe.

Parameters

universe	universe to which to add the cell
cell	cell to add

Definition at line 525 of file CSGBase.C.

{
  // if universe is actually engineering unit, cannot add cells
  if (universeToEngUnit(universe))
    mooseError("Universe '" + universe.getName() +
               "' cannot add cells because it is a CSGUniverseEngUnit.");
 
  // make sure cell is a part of this CSGBase instance
  if (!checkCellInBase(cell))
    mooseError("A cell named " + cell.getName() + " is being added to universe " +
               universe.getName() +
               " that is different from the cell of the same name in the CSGBase instance.");
  // make sure universe is a part of this CSGBase instance
  if (!checkUniverseInBase(universe))
    mooseError("Cells are being added to a universe named " + universe.getName() +
               " that is different " +
               "from the universe of the same name in the CSGBase instance.");
  auto & univ = _universe_list.getUniverse(universe.getName());
  univ.addCell(cell);
}

Referenced by addEngUnit(), and CSGBase().

◆ addEngUnit()

template<typename T >

const T & CSG::CSGBase::addEngUnit	(	std::unique_ptr< T >	unit,
		const CSGUniverse *	add_to_univ = `nullptr`
	)

inline

Add an engineering unit (surface-, cell-, or universe-like object) to this CSGBase.

Template Parameters

T	a type derived from CSGSurfaceEngUnit, CSGCellEngUnit, or CSGUniverseEngUnit

Parameters

unit	unique_ptr to the engineering unit to register
add_to_univ	optional pointer to a CSGUniverse object to which a CSGCellEngUnit should be added. If not specified, the CSGCellEngUnit will be added to the root universe. For other CSGEngUnit types, this will be ignored. This universe cannot be a CSGUniverseEngUnit.

Returns: const reference to the stored engineering unit

Definition at line 539 of file CSGBase.h.

  {
    static_assert(std::is_base_of_v<CSGEngUnit, T>, "T must derive from CSGEngUnit");
    static_assert(std::is_base_of_v<CSGSurface, T> || std::is_base_of_v<CSGCell, T> ||
                      std::is_base_of_v<CSGUniverse, T>,
                  "T must also derive from CSGSurface, CSGCell, or CSGUniverse");
    // create raw pointer so we can transfer ownership to the proper type list without destroying
    // it, and also can store the pointer in the CSGEngUnitList (non-owning list)
    T * raw = unit.get();
 
    // must check if an engineering unit of the same name (regardless of type) exists already before
    // adding it to any list so that we don't add to a type-list before knowing if it is actually
    // allowable as a unit. The addX checks below will check that the name doesn't conflict with a
    // real type unit too.
    if (_eng_unit_list.hasEngUnit(raw->getName()))
      mooseError(
          "An engineering unit with name '", raw->getName(), "' already exists in geometry.");
 
    // Transfer ownership to the appropriate type list
    if constexpr (std::is_base_of_v<CSGSurface, T>)
      _surface_list.addSurface(std::move(unit));
    else if constexpr (std::is_base_of_v<CSGCell, T>)
    {
      // must add a cell unit to the appropriate universe
      auto & cell = _cell_list.addCell(std::move(unit));
      if (add_to_univ)
        addCellToUniverse(*add_to_univ, cell);
      else
        addCellToUniverse(getRootUniverse(), cell);
    }
    else if constexpr (std::is_base_of_v<CSGUniverse, T>)
      _universe_list.addUniverse(std::move(unit));
 
    // Register non-owning pointer in the CSGEngUnitList if no name conflicts identified above.
    _eng_unit_list.addEngUnit(cast_ref<CSGEngUnit &>(*raw));
    return *raw;
  }

Referenced by CSGBase().

◆ addLattice()

template<typename LatticeType = CSGLattice>

const LatticeType & CSG::CSGBase::addLattice ( std::unique_ptr< LatticeType > lattice )

inline

add a unique lattice pointer to this base instance; universes that make the lattice must already be a part of this CSGBase instance.

Parameters

lattice pointer to lattice to add

Returns: reference to CSGLattice that was added

Definition at line 398 of file CSGBase.h.

  {
    static_assert(std::is_base_of_v<CSGLattice, LatticeType>, "Is not a CSGLattice");
    // make sure all universes are a part of this base instance
    auto universes = lattice->getUniverses();
    for (auto univ_list : universes)
      for (const CSGUniverse & univ : univ_list)
        if (!checkUniverseInBase(univ))
          mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
                     ". Universe " + univ.getName() + " is not in the CSGBase instance.");
 
    if (lattice->getOuterType() == "UNIVERSE")
    {
      const CSGUniverse & outer_univ = lattice->getOuterUniverse();
      if (!checkUniverseInBase(outer_univ))
        mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
                   ". Outer universe " + outer_univ.getName() + " is not in the CSGBase instance.");
    }
    auto & lat_ref = _lattice_list.addLattice(std::move(lattice));
    return dynamic_cast<LatticeType &>(lat_ref);
  }

◆ addLatticeToList()

const CSGLattice & CSG::CSGBase::addLatticeToList ( const CSGLattice & lattice )

private

Add a new lattice to the lattice list based on a lattice reference.

This method is called by the copy constructor of CSGBase

Parameters

lattice reference to CSGLattice that should be added to universe list

Definition at line 202 of file CSGBase.C.

{
  // If lattice has already been created, we just return a reference to it
  const auto name = lattice.getName();
  if (_lattice_list.hasLattice(name))
    return _lattice_list.getLattice(name);
 
  // Clone the lattice (associated universes need to be transferred and set)
  auto cloned_lattice = lattice.clone();
 
  // If lattice has associated universes, we need to add them to this CSGBase instance as well.
  // addUniverseToList is called recursively in case associated universes have not been added to
  // the universe list yet.
  std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> current_univ_map;
  for (const auto & univ_list : lattice.getUniverses())
  {
    std::vector<std::reference_wrapper<const CSGUniverse>> current_univ_list;
    for (const auto & univ_ref : univ_list)
      current_univ_list.push_back(addUniverseToList(univ_ref.get()));
    current_univ_map.push_back(current_univ_list);
  }
 
  // Set universes only if lattice has universes defined
  if (current_univ_map.size() > 0)
    cloned_lattice->setUniverses(current_univ_map);
 
  // Update reference to outer universe if it exists
  if (lattice.getOuterType() == "UNIVERSE")
  {
    const auto & outer_univ_ref = addUniverseToList(lattice.getOuterUniverse());
    cloned_lattice->updateOuter(outer_univ_ref);
  }
 
  // Use addLattice to add the cloned lattice
  return addLattice(std::move(cloned_lattice));
}

Referenced by CSGBase().

◆ addSurface()

const CSGSurface & CSG::CSGBase::addSurface ( std::unique_ptr< CSGSurface > surf )

add a unique surface pointer to this base instance

Parameters

surf	pointer to surface to add

Returns: reference to CSGSurface that was added

Definition at line 96 of file CSGBase.C.

{
  if (surfaceToEngUnit(*surf))
    mooseError("Surface '",
               surf->getName(),
               "' is a CSGSurfaceEngUnit and must be added via addEngUnit(), not addSurface().");
  return _surface_list.addSurface(std::move(surf));
}

◆ addTransformation() [1/2]

void CSG::CSGBase::addTransformation	(	const CSGEngUnit &	unit,
		TransformationType	type,
		const std::tuple< Real, Real, Real > &	values
	)

inline

Apply a transformation to a CSGEngUnit object.

Parameters

unit	The CSGEngUnit object to transform (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
type	The type of transformation to apply (TRANSLATION, ROTATION, SCALE)
values	tuple of transformation values (3 values for any transformation type)

Note: Required because engineering unit types derive from both a plain CSG base and CSGEngUnit, so passing one to the CSGObjectVariant overload is ambiguous and will not compile; this overload binds to CSGEngUnit directly to disambiguate.

Definition at line 807 of file CSGBase.h.

  {
    addTransformation(CSGObjectVariant{std::cref(unit)}, type, values);
  }

◆ addTransformation() [2/2]

void CSG::CSGBase::addTransformation	(	const CSGObjectVariant &	csg_object,
		TransformationType	type,
		const std::tuple< Real, Real, Real > &	values
	)

Apply a transformation to a CSG object.

Parameters

csg_object	The CSG object to transform (Surface, Cell, Universe, Region, or Lattice)
type	The type of transformation to apply (TRANSLATION, ROTATION, SCALE)
values	tuple of transformation values (3 values for any transformation type)

Definition at line 653 of file CSGBase.C.

{
  // Use std::visit to handle each type in the variant
  std::visit(
      [&](const auto & obj)
      {
        using T = std::decay_t<decltype(obj.get())>;
 
        // Handle each CSG object type differently because each needs to check that it exists in
        // this base instance
        if constexpr (std::is_same_v<T, CSGCell>)
        {
          const CSGCell & cell = obj.get();
          if (!checkCellInBase(cell))
            mooseError("Cannot apply transformation to cell ",
                       cell.getName(),
                       " that is not in this CSGBase instance.");
 
          // Get non-const reference and apply transformation
          CSGCell & mutable_cell = _cell_list.getCell(cell.getName());
          mooseAssert(mutable_cell == cell, "Mutable cell does not match const cell passed in.");
          mutable_cell.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGSurface>)
        {
          const CSGSurface & surface = obj.get();
          if (!checkSurfaceInBase(surface))
            mooseError("Cannot apply transformation to surface ",
                       surface.getName(),
                       " that is not in this CSGBase instance.");
 
          // Get non-const reference and apply transformation
          CSGSurface & mutable_surface = _surface_list.getSurface(surface.getName());
          mooseAssert(mutable_surface == surface,
                      "Mutable surface does not match const surface passed in.");
          mutable_surface.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGUniverse>)
        {
          const CSGUniverse & universe = obj.get();
          if (!checkUniverseInBase(universe))
            mooseError("Cannot apply transformation to universe ",
                       universe.getName(),
                       " that is not in this CSGBase instance.");
 
          // Get non-const reference and apply transformation
          CSGUniverse & mutable_universe = _universe_list.getUniverse(universe.getName());
          mooseAssert(mutable_universe == universe,
                      "Mutable universe does not match const universe passed in.");
          mutable_universe.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGLattice>)
        {
          const CSGLattice & lattice = obj.get();
          if (!checkLatticeInBase(lattice))
            mooseError("Cannot apply transformation to lattice ",
                       lattice.getName(),
                       " that is not in this CSGBase instance.");
 
          // Get non-const reference and apply transformation
          CSGLattice & mutable_lattice = _lattice_list.getLattice(lattice.getName());
          mooseAssert(mutable_lattice == lattice,
                      "Mutable lattice does not match const lattice passed in.");
          mutable_lattice.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGRegion>)
        {
          // iterate on the surfaces of the region and apply the transformation to those surfaces
          const CSGRegion & region = obj.get();
          const auto surfaces = region.getSurfaces();
          for (const CSGSurface & surface : surfaces)
          {
            if (!checkSurfaceInBase(surface))
              mooseError("Cannot apply transformation to region with surface ",
                         surface.getName(),
                         " that is not in this CSGBase instance.");
            addTransformation(surface, type, values);
          }
        }
        else if constexpr (std::is_same_v<T, CSGEngUnit>)
        {
          const CSGEngUnit & eng_unit = obj.get();
          if (!checkEngUnitInBase(eng_unit))
            mooseError("Cannot apply transformation to engineering unit ",
                       eng_unit.getName(),
                       " that is not in this CSGBase instance.");
 
          CSGEngUnit & mutable_eng = _eng_unit_list.getEngUnit(eng_unit.getName());
          if (auto * s = dynamic_cast<CSGSurfaceEngUnit *>(&mutable_eng))
            s->addTransformation(type, values);
          else if (auto * c = dynamic_cast<CSGCellEngUnit *>(&mutable_eng))
            c->addTransformation(type, values);
          else if (auto * u = dynamic_cast<CSGUniverseEngUnit *>(&mutable_eng))
            u->addTransformation(type, values);
          else
            mooseError("Engineering unit '",
                       eng_unit.getName(),
                       "' has an unrecognized type for transformation.");
        }
        else
          mooseError("Transformation not implemented for this object type: ", typeid(T).name());
      },
      csg_object);
}

Referenced by addTransformation(), applyRotation(), applyRotation(), applyScaling(), applyScaling(), applyTranslation(), and applyTranslation().

◆ addUniverseToList()

const CSGUniverse & CSG::CSGBase::addUniverseToList ( const CSGUniverse & univ )

private

Add a new universe to the universe list based on a universe reference.

This method is called by the copy constructor of CSGBase

Parameters

univ	reference to CSGUniverse that should be added to universe list

Definition at line 177 of file CSGBase.C.

{
  // If universe has already been created, we just return a reference to it
  const auto name = univ.getName();
  if (_universe_list.hasUniverse(name))
    return _universe_list.getUniverse(name);
 
  // Engineering unit universes must be registered via addEngUnit(), not addUniverseToList()
  if (universeToEngUnit(univ))
    mooseError("Universe '",
               name,
               "' is a CSGUniverseEngUnit and must be added via addEngUnit(), not "
               "addUniverseToList().");
 
  // Otherwise we create a new universe based on its associated cells.
  // addCellToList is called recursively in case associated cells have not
  // been added to the cell list yet.
  const auto univ_cells = univ.getAllCells();
  std::vector<std::reference_wrapper<const CSGCell>> current_univ_cells;
  for (const auto & univ_cell : univ_cells)
    current_univ_cells.push_back(addCellToList(univ_cell));
  return createUniverse(name, current_univ_cells);
}

Referenced by CSGBase().

◆ applyAxisRotation() [1/2]

void CSG::CSGBase::applyAxisRotation	(	const CSGEngUnit &	unit,
		RotationAxisType	axis,
		const Real	angle
	)

inline

Apply a rotation to a CSGEngUnit object about a specified axis (X, Y, Z).

Parameters

unit	The CSGEngUnit object to rotate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
axis	Axis type (X, Y, or Z) about which to rotate
angle	angle in degrees to rotate about the specified axis

Note: Required because engineering unit types derive from both a plain CSG base and CSGEngUnit, so passing one to the CSGObjectVariant overload is ambiguous and will not compile; this overload binds to CSGEngUnit directly to disambiguate.

Definition at line 893 of file CSGBase.h.

  {
    applyAxisRotation(CSGObjectVariant{std::cref(unit)}, axis, angle);
  }

◆ applyAxisRotation() [2/2]

void CSG::CSGBase::applyAxisRotation	(	const CSGObjectVariant &	csg_object,
		RotationAxisType	axis,
		const Real	angle
	)

Apply a rotation to a CSG object about a specified axis (X, Y, Z).

Parameters

csg_object	The CSG object to rotate (Surface, Cell, Universe, Region, or Lattice)
axis	Axis type (X, Y, or Z) about which to rotate
angle	angle in degrees to rotate about the specified axis

Definition at line 761 of file CSGBase.C.

{
  // convert to the Euler angles (phi, theta, psi) based on axis
  Real phi = 0.0;
  Real theta = 0.0;
  Real psi = 0.0;
 
  switch (axis)
  {
    case RotationAxisType::X:
      theta = angle;
      break;
    case RotationAxisType::Y:
      phi = 90.0;
      theta = angle;
      psi = -90.0;
      break;
    case RotationAxisType::Z:
      phi = angle;
      break;
    default:
      mooseError("Invalid axis type provided for axis rotation.");
  }
 
  addTransformation(csg_object, TransformationType::ROTATION, std::make_tuple(phi, theta, psi));
}

Referenced by applyAxisRotation().

◆ applyRotation() [1/2]

void CSG::CSGBase::applyRotation	(	const CSGEngUnit &	unit,
		const std::tuple< Real, Real, Real > &	angles
	)

inline

Apply a rotation to a CSG object using (phi, theta, psi) angle notation (in degrees).

Parameters

unit	The CSGEngUnit object to rotate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
angles	size 3 tuple {phi, theta, psi} with rotation angles in degrees

Note: Required because engineering unit types derive from both a plain CSG base and CSGEngUnit, so passing one to the CSGObjectVariant overload is ambiguous and will not compile; this overload binds to CSGEngUnit directly to disambiguate.

Definition at line 866 of file CSGBase.h.

  {
    addTransformation(unit, TransformationType::ROTATION, angles);
  }

◆ applyRotation() [2/2]

void CSG::CSGBase::applyRotation	(	const CSGObjectVariant &	csg_object,
		const std::tuple< Real, Real, Real > &	angles
	)

inline

Apply a rotation to a CSG object using (phi, theta, psi) angle notation (in degrees).

Parameters

csg_object	The CSG object to rotate (Surface, Cell, Universe, Region, or Lattice)
angles	size 3 tuple {phi, theta, psi} with rotation angles in degrees

Definition at line 849 of file CSGBase.h.

  {
    addTransformation(csg_object, TransformationType::ROTATION, angles);
  }

◆ applyScaling() [1/2]

void CSG::CSGBase::applyScaling	(	const CSGEngUnit &	unit,
		const std::tuple< Real, Real, Real > &	values
	)

inline

Scale a CSGEngUnit object in the specified x, y, and z directions.

Parameters

unit	The CSGEngUnit object to scale (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
values	size 3 tuple with scaling values in x, y, and z directions {x, y, z}

Note: Required because engineering unit types derive from both a plain CSG base and CSGEngUnit, so passing one to the CSGObjectVariant overload is ambiguous and will not compile; this overload binds to CSGEngUnit directly to disambiguate.

Definition at line 921 of file CSGBase.h.

  {
    addTransformation(unit, TransformationType::SCALE, values);
  }

◆ applyScaling() [2/2]

void CSG::CSGBase::applyScaling	(	const CSGObjectVariant &	csg_object,
		const std::tuple< Real, Real, Real > &	values
	)

inline

Scale a CSG object in the specified x, y, and z directions.

Parameters

csg_object	The CSG object to scale (Surface, Cell, Universe, Region, or Lattice)
values	size 3 tuple with scaling values in x, y, and z directions {x, y, z}

Definition at line 904 of file CSGBase.h.

  {
    addTransformation(csg_object, TransformationType::SCALE, values);
  }

◆ applyTranslation() [1/2]

void CSG::CSGBase::applyTranslation	(	const CSGEngUnit &	unit,
		const std::tuple< Real, Real, Real > &	distances
	)

inline

Apply a translation to a CSGEngUnit object in the specified x, y, and z directions.

Parameters

unit	The CSGEngUnit object to translate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
distances	size 3 tuple with translation distances in x, y, and z directions {x, y, z}

Note: Required because engineering unit types derive from both a plain CSG base and CSGEngUnit, so passing one to the CSGObjectVariant overload is ambiguous and will not compile; this overload binds to CSGEngUnit directly to disambiguate.

Definition at line 838 of file CSGBase.h.

  {
    addTransformation(unit, TransformationType::TRANSLATION, distances);
  }

◆ applyTranslation() [2/2]

void CSG::CSGBase::applyTranslation	(	const CSGObjectVariant &	csg_object,
		const std::tuple< Real, Real, Real > &	distances
	)

inline

Apply a translation to a CSG object in the specified x, y, and z directions.

Parameters

csg_object	The CSG object to translate (Surface, Cell, Universe, Region, or Lattice)
distances	size 3 tuple with translation distances in x, y, and z directions {x, y, z}

Definition at line 820 of file CSGBase.h.

  {
    addTransformation(csg_object, TransformationType::TRANSLATION, distances);
  }

◆ areCSGObjectsLinked()

bool CSG::CSGBase::areCSGObjectsLinked ( ) const

Check whether all universes, cells, and surfaces in this CSGBase are reachable from the root universe through the cell/fill hierarchy.

Returns: true if all are linked, false if any universe, cell, or surface is orphaned

Definition at line 1236 of file CSGBase.C.

{
  std::set<std::string> linked_univs, linked_cells, linked_surfs;
  getLinkedCSGObjects(getRootUniverse(), linked_univs, linked_cells, linked_surfs);
 
  for (const CSGUniverse & univ : getAllUniverses())
    if (linked_univs.find(univ.getName()) == linked_univs.end())
      return false;
 
  for (const CSGCell & cell : getAllCells())
    if (linked_cells.find(cell.getName()) == linked_cells.end())
      return false;
 
  for (const CSGSurface & surf : getAllSurfaces())
    if (linked_surfs.find(surf.getName()) == linked_surfs.end())
      return false;
 
  return true;
}

◆ cellToEngUnit()

const CSGCellEngUnit * CSG::CSGBase::cellToEngUnit ( const CSGCell & cell ) const

inlineprivate

Returns the CSGCellEngUnit pointer if cell is an eng unit, nullptr otherwise.

Usable as a boolean check or to access the eng unit directly.

Parameters

cell	CSGCell to check/get as an engineering unit

Returns: const CSGCellEngUnit* or nullptr

Definition at line 1219 of file CSGBase.h.

  {
    return dynamic_cast<const CSGCellEngUnit *>(&cell);
  }

Referenced by CSGBase().

◆ checkCellInBase()

bool CSG::CSGBase::checkCellInBase ( const CSGCell & cell ) const

private

check that cell being accessed is a part of this CSGBase instance

Definition at line 1108 of file CSGBase.C.

{
  auto name = cell.getName();
  // if no cell by this name exists, an error will be produced by getCell
  auto & list_cell = _cell_list.getCell(name);
  // return whether the cell in the list is the same object as the one provided
  return &cell == &list_cell;
}

◆ checkEngUnitInBase()

bool CSG::CSGBase::checkEngUnitInBase ( const CSGEngUnit & unit ) const

private

check that engineering unit being accessed is a part of this CSGBase instance

Definition at line 1138 of file CSGBase.C.

{
  const auto & name = unit.getName();
  // if no engineering unit by this name exists, an error will be produced by getEngUnit
  const auto & list_unit = _eng_unit_list.getEngUnit(name);
  // compare CSGEngUnit subobject addresses
  return &unit == &list_unit;
}

◆ checkLatticeInBase()

bool CSG::CSGBase::checkLatticeInBase ( const CSGLattice & lattice ) const

private

check that lattice being accessed is a part of this CSGBase instance

Definition at line 1128 of file CSGBase.C.

{
  auto name = lattice.getName();
  // if no lattice by this name exists, an error will be produced by getLattice
  auto & list_lattice = _lattice_list.getLattice(name);
  // return whether that the lattice in the list is the same as the lattice provided (in memory)
  return &lattice == &list_lattice;
}

◆ checkRegionSurfaces()

void CSG::CSGBase::checkRegionSurfaces ( const CSGRegion & region ) const

private

check that surfaces used in this region are a part of this CSGBase instance

Definition at line 1086 of file CSGBase.C.

{
  const auto surfs = region.getSurfaces();
  for (const CSGSurface & s : surfs)
  {
    if (!checkSurfaceInBase(s))
      mooseError("Region is being set with a surface named " + s.getName() +
                 " that is different from the surface of the same name in the CSGBase instance.");
  }
}

◆ checkSurfaceInBase()

bool CSG::CSGBase::checkSurfaceInBase ( const CSGSurface & surface ) const

private

check that surface being accessed is a part of this CSGBase instance

Definition at line 1098 of file CSGBase.C.

{
  auto name = surface.getName();
  // if no surface by this name exists, an error will be produced by getSurface
  auto & list_surf = _surface_list.getSurface(name);
  // return whether the surface in the list is the same object as the one provided
  return &surface == &list_surf;
}

◆ checkUniverseInBase()

bool CSG::CSGBase::checkUniverseInBase ( const CSGUniverse & universe ) const

private

check that universe being accessed is a part of this CSGBase instance

Definition at line 1118 of file CSGBase.C.

{
  auto name = universe.getName();
  // if no universe by this name exists, an error will be produced by getUniverse
  auto & list_univ = _universe_list.getUniverse(name);
  // return whether the universe in the list is the same object as the one provided
  return &universe == &list_univ;
}

Referenced by addLattice().

◆ checkUniverseLinking()

void CSG::CSGBase::checkUniverseLinking ( ) const

private

Check universes linked to root universe match universes defined in _universe_list.

Definition at line 1206 of file CSGBase.C.

{
  std::set<std::string> linked_universe_names;
  std::set<std::string> linked_cell_names;
  std::set<std::string> linked_surf_names;
 
  // Recursively figure out which CSG objects are linked to root universe
  getLinkedCSGObjects(
      getRootUniverse(), linked_universe_names, linked_cell_names, linked_surf_names);
 
  // Iterate through all universes in universe list and check that they exist in universes linked
  // to root universe list. Universe list includes CSGUniverseEngUnits.
  for (const CSGUniverse & univ : getAllUniverses())
    if (linked_universe_names.find(univ.getName()) == linked_universe_names.end())
      mooseWarning("Universe with name ", univ.getName(), " is not linked to root universe.");
 
  // Iterate through all cells in cell list and check that they exist in cells linked
  // to root universe
  for (const CSGCell & cell : getAllCells())
    if (linked_cell_names.find(cell.getName()) == linked_cell_names.end())
      mooseWarning("Cell with name ", cell.getName(), " is not linked to root universe.");
 
  // Iterate through all surfaces in surface list and check that they exist in surfaces linked
  // to root universe
  for (const CSGSurface & surf : getAllSurfaces())
    if (linked_surf_names.find(surf.getName()) == linked_surf_names.end())
      mooseWarning("Surface with name ", surf.getName(), " is not linked to root universe.");
}

◆ clone()

std::unique_ptr< CSGBase > CSG::CSGBase::clone ( ) const

Create a deep copy of this CSGBase instance.

This method calls std::make_unique to create the deep copy. However, the surface references of all cloned cells are updated manually to make sure they point to the surfaces of the cloned object and not the original CSGBase instance.

Definition at line 78 of file CSGBase.C.

{
  std::unique_ptr<CSGBase> clone = std::make_unique<CSGBase>(*this);
 
  // Store list of surface names to surface references in clone to update region definitions
  std::map<std::string, std::reference_wrapper<const CSGSurface>> identical_surface_refs;
  auto & surf_list_map = clone->getSurfaceList().getSurfaceListMap();
  for (const auto & [surf_name, surf_ptr] : surf_list_map)
    identical_surface_refs.insert({surf_name, clone->getSurfaceByName(surf_name)});
 
  // Update surface references of cell regions to those of clone
  for (auto & [cell_name, cell_ptr] : clone->getCellList().getCellListMap())
    cell_ptr->updateCellRegionSurfaces(identical_surface_refs);
 
  return clone;
}

Referenced by clone().

◆ createCell() [1/4]

const CSGCell & CSG::CSGBase::createCell	(	const std::string &	name,
		const CSGLattice &	fill_lattice,
		const CSGRegion &	region,
		const CSGUniverse *	add_to_univ = `nullptr`
	)

Create a Lattice Cell object.

Parameters

name	unique cell name
fill_lattice	lattice that will fill the cell
region	cell region
add_to_univ	(optional) universe to which this cell will be added (default is root universe)

Returns: reference to cell that is created

Definition at line 311 of file CSGBase.C.

{
  checkRegionSurfaces(region);
 
  // check that cell is not being added to a universe that exists in the lattice itself
  if (add_to_univ)
    for (auto univ_list : fill_lattice.getUniverses())
      for (const auto & univ_ref : univ_list)
      {
        const CSGUniverse & univ_in_lattice = univ_ref.get();
        if (&univ_in_lattice == add_to_univ)
          mooseError("Cell " + name +
                     " cannot be filled with a lattice containing the same universe to which it is "
                     "being added.");
      }
 
  auto & cell = _cell_list.addLatticeCell(name, fill_lattice, region);
  if (add_to_univ)
    addCellToUniverse(*add_to_univ, cell);
  else
    addCellToUniverse(getRootUniverse(), cell);
  return cell;
}

◆ createCell() [2/4]

const CSGCell & CSG::CSGBase::createCell	(	const std::string &	name,
		const CSGRegion &	region,
		const CSGUniverse *	add_to_univ = `nullptr`
	)

Create a Void Cell object.

Parameters

name	unique cell name
region	cell region
add_to_univ	(optional) universe to which this cell will be added (default is root universe)

Returns: reference to CSGCell that is created

Definition at line 278 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  auto & cell = _cell_list.addVoidCell(name, region);
  if (add_to_univ)
    addCellToUniverse(*add_to_univ, cell);
  else
    addCellToUniverse(getRootUniverse(), cell);
  return cell;
}

◆ createCell() [3/4]

const CSGCell & CSG::CSGBase::createCell	(	const std::string &	name,
		const CSGUniverse &	fill_univ,
		const CSGRegion &	region,
		const CSGUniverse *	add_to_univ = `nullptr`
	)

Create a Universe Cell object.

Parameters

name	unique cell name
fill_univ	universe that will fill the cell
region	cell region
add_to_univ	(optional) universe to which this cell will be added (default is root universe)

Returns: reference to cell that is created

Definition at line 292 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  if (add_to_univ && (&fill_univ == add_to_univ))
    mooseError("Cell " + name +
               " cannot be filled with the same universe to which it is being added.");
 
  auto & cell = _cell_list.addUniverseCell(name, fill_univ, region);
  if (add_to_univ)
    addCellToUniverse(*add_to_univ, cell);
  else
    addCellToUniverse(getRootUniverse(), cell);
  return cell;
}

◆ createCell() [4/4]

const CSGCell & CSG::CSGBase::createCell	(	const std::string &	name,
		const std::string &	mat_name,
		const CSGRegion &	region,
		const CSGUniverse *	add_to_univ = `nullptr`
	)

Create a Material Cell object.

Parameters

name	unique cell name
mat_name	material name
region	cell region
add_to_univ	(optional) universe to which this cell will be added (default is root universe)

Returns: reference to CSGCell that is created

Definition at line 263 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  auto & cell = _cell_list.addMaterialCell(name, mat_name, region);
  if (add_to_univ)
    addCellToUniverse(*add_to_univ, cell);
  else
    addCellToUniverse(getRootUniverse(), cell);
  return cell;
}

◆ createUniverse() [1/2]

const CSGUniverse & CSG::CSGBase::createUniverse ( const std::string & name )

inline

Create an empty Universe object.

Parameters

name	unique universe name

Returns: reference to CSGUniverse that is created

Definition at line 303 of file CSGBase.h.

  {
    return _universe_list.addUniverse(name);
  }

◆ createUniverse() [2/2]

const CSGUniverse & CSG::CSGBase::createUniverse	(	const std::string &	name,
		std::vector< std::reference_wrapper< const CSGCell > > &	cells
	)

Create a Universe object from list of cells.

Parameters

name	unique universe name
cells	list of cells to add to universe

Returns: reference to CSGUniverse that is created

Definition at line 467 of file CSGBase.C.

{
  auto & univ = _universe_list.addUniverse(name);
  addCellsToUniverse(univ, cells); // performs a check that cells are a part of this base
  return univ;
}

◆ deleteCell()

void CSG::CSGBase::deleteCell ( const CSGCell & cell )

Remove a Cell object passed in by reference from the stored cell list.

Any CSG components connected to cell will not be recursively removed.

Parameters

cell	reference to cell to delete

Definition at line 361 of file CSGBase.C.

{
  if (!checkCellInBase(cell))
    mooseError("Cell with name ",
               cell.getName(),
               " cannot be deleted as it is different from the cell of the same name in the "
               "CSGBase instance.");
 
  prepareCellDeletion(cell);
  if (const auto * eng_unit = cellToEngUnit(cell))
    _eng_unit_list.removeEngUnit(*eng_unit);
  _cell_list.getCellListMap().erase(cell.getName());
}

◆ deleteEngUnit()

void CSG::CSGBase::deleteEngUnit ( const CSGEngUnit & unit )

Remove an engineering unit passed in by reference from the stored engineering unit list.

Parameters

unit	reference to the engineering unit to delete

Definition at line 1295 of file CSGBase.C.

{
  if (!checkEngUnitInBase(unit))
    mooseError("Engineering unit with name ",
               unit.getName(),
               " cannot be deleted as it is different from the engineering unit of the same name "
               "in the CSGBase instance.");
 
  // Delegate to the typed delete method which handles EngUnit index cleanup and type list erasure
  if (const auto * surf_unit = dynamic_cast<const CSGSurfaceEngUnit *>(&unit))
    deleteSurface(cast_ref<const CSGSurface &>(*surf_unit));
  else if (const auto * cell_unit = dynamic_cast<const CSGCellEngUnit *>(&unit))
    deleteCell(cast_ref<const CSGCell &>(*cell_unit));
  else if (const auto * univ_unit = dynamic_cast<const CSGUniverseEngUnit *>(&unit))
    deleteUniverse(cast_ref<const CSGUniverse &>(*univ_unit));
  else
    mooseError(
        "Engineering unit '", unit.getName(), "' has an unrecognized type and cannot be deleted.");
}

◆ deleteLattice()

void CSG::CSGBase::deleteLattice ( const CSGLattice & lattice )

Remove a Lattice object passed in by reference from the stored lattice list.

Any CSG components connected to lattice will not be recursively removed.

Parameters

lattice reference to lattice to delete

Definition at line 240 of file CSGBase.C.

{
  if (!checkLatticeInBase(lattice))
    mooseError("Lattice with name ",
               lattice.getName(),
               " cannot be deleted as it is different from the lattice of the same name in the "
               "CSGBase instance.");
 
  // Check if lattice is used as fill in existing cells
  for (const auto & cell_ref : _cell_list.getAllCells())
  {
    const auto & cell = cell_ref.get();
    if ((cell.getFillType() == "LATTICE") && (cell.getFillLattice() == lattice))
      mooseError("Cannot delete lattice with name ",
                 lattice.getName(),
                 " as it is used as the fill of cell with name ",
                 cell.getName());
  }
 
  _lattice_list.getLatticeListMap().erase(lattice.getName());
}

◆ deleteSurface()

void CSG::CSGBase::deleteSurface ( const CSGSurface & surface )

Remove a Surface object passed in by reference from the stored surface list.

Any CSG components connected to surface will not be recursively removed.

Parameters

surface reference to surface to delete

Definition at line 121 of file CSGBase.C.

{
  if (!checkSurfaceInBase(surface))
    mooseError("Surface with name ",
               surface.getName(),
               " cannot be deleted as it is different from the surface of the same name in the "
               "CSGBase instance.");
 
  prepareSurfaceDeletion(surface);
  if (const auto * eng_unit = surfaceToEngUnit(surface))
    _eng_unit_list.removeEngUnit(*eng_unit);
  _surface_list.getSurfaceListMap().erase(surface.getName());
}

◆ deleteUniverse()

void CSG::CSGBase::deleteUniverse ( const CSGUniverse & univ )

Remove a Universe object passed in by reference from the stored universe list.

Any CSG components connected to universe will not be recursively removed.

Parameters

univ	reference to universe to delete

Definition at line 510 of file CSGBase.C.

{
  if (!checkUniverseInBase(univ))
    mooseError("Universe with name ",
               univ.getName(),
               " cannot be deleted as it is different from the universe of the same name in the "
               "CSGBase instance.");
 
  prepareUniverseDeletion(univ);
  if (const auto * eng_unit = universeToEngUnit(univ))
    _eng_unit_list.removeEngUnit(*eng_unit);
  _universe_list.getUniverseListMap().erase(univ.getName());
}

◆ expandAllEngUnits()

void CSG::CSGBase::expandAllEngUnits ( )

Expand all registered engineering units into basic CSG objects.

Each expanded EngUnit is removed from the engineering unit list and replaced by the corresponding plain CSG object(s) in the standard lists. After this call, the engineering unit list is empty.

Definition at line 1316 of file CSGBase.C.

{
  std::set<std::set<std::string>> all_type_sets;
  expandAllEngUnitsCycle(all_type_sets);
}

◆ expandAllEngUnitsCycle()

void CSG::CSGBase::expandAllEngUnitsCycle ( std::set< std::set< std::string > > & all_type_sets )

private

Recursive implementation of expandAllEngUnits().

Each call is one pass: all eng units currently in the base are expanded, then if new units were created the function calls itself to expand them. The set of unit types present at the start of each pass is recorded. If that exact combination was seen in a prior pass, expansion is detected to be a circular dependency and an error is raised.

Parameters

all_type_sets set of the sets of types seen in each pass of expandAllEngUnitsCycle

Definition at line 1323 of file CSGBase.C.

{
  // One call to this function is one pass: collect all current eng units, expand them, then
  // recurse if expansion created new units. Units created during a pass are not in this pass's
  // snapshot; they are handled in the next pass.
  //
  // Cycle check: if the same combination of unit types appeared at the start of a prior pass,
  // expansion is stuck repeating the same configuration. Tracking the full type-set (not
  // individual types) prevents false positives when a type reappears because it was produced
  // by a different type's expansion rather than its own.
  std::set<std::string> current_types;
  for (const auto & u : getAllEngUnits())
    current_types.insert(u.get().getUnitType());
 
  if (all_type_sets.count(
          current_types)) // this expansion set was already captured which means we are cycling
    mooseError("Circular dependency detected in engineering unit expansion");
 
  all_type_sets.insert(current_types);
 
  // Snapshot raw pointers before expanding. Units are destroyed after expansion so iterating live
  // references would dangle.
  std::vector<const CSGSurfaceEngUnit *> surfs;
  std::vector<const CSGCellEngUnit *> cells;
  std::vector<const CSGUniverseEngUnit *> univs;
  for (const auto & u : getAllSurfaceEngUnits())
    surfs.push_back(&u.get());
  for (const auto & u : getAllCellEngUnits())
    cells.push_back(&u.get());
  for (const auto & u : getAllUniverseEngUnits())
    univs.push_back(&u.get());
 
  // Expand all units in this pass
  for (const auto * s : surfs)
    expandEngUnit(*s);
  for (const auto * c : cells)
    expandEngUnit(*c);
  for (const auto * u : univs)
    expandEngUnit(*u);
 
  // if engineering units exist after completion of all expansions above, then start the next "pass"
  // through this expansion process. This will create a new set of "current_types" to check.
  if (!getAllEngUnits().empty())
    expandAllEngUnitsCycle(all_type_sets);
}

◆ expandEngUnit() [1/3]

const CSGCell & CSG::CSGBase::expandEngUnit ( const CSGCellEngUnit & unit )

Expand a cell-like engineering unit into a basic CSGCell.

Calls expandUnit() on the EngUnit to create a basic CSGCell, then replaces every reference to the EngUnit in every universe with the new expanded CSGCell. The EngUnit is then removed from the engineering unit list and destroyed.

Parameters

unit	identifies the CSGCellEngUnit to expand. Passed by const reference because the expansion does not mutate through this handle; it operates on and consumes the owned instance re-fetched from the cell list by name.

Returns: const reference to the expanded CSGCell

Definition at line 1418 of file CSGBase.C.

{
  // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
  // reference to the same object from the owning cell list to perform the expansion, which
  // mutates and consumes the unit (expandUnit() is non-const).
  auto & mutable_unit = cast_ref<CSGCellEngUnit &>(_cell_list.getCell(unit.getName()));
 
  // Derived class populates an internal base object (owned by the unit) with the expanded cell (in
  // root) and any supports
  mutable_unit.expandUnit();
 
  // Capture a reference to the expanded cell before the join. joinOtherBase transfers ownership
  // of the cell's unique_ptr but does not relocate the object, so the reference stays valid.
  // getExpandedCell also validates that root has exactly 1 cell.
  const CSGCell & expanded_cell = mutable_unit.getExpandedCell();
 
  // Join the unit's base object: 1-param merges root cells into this root
  joinOtherBase(mutable_unit.releaseBase(), false);
 
  // Propagate any stored transformations from the EngUnit to the expanded cell
  const auto & trans = cast_ref<const CSGCell &>(mutable_unit).getTransformations();
  if (!trans.empty())
  {
    CSGCell & mutable_cell = _cell_list.getCell(expanded_cell.getName());
    for (const auto & [trans_type, values] : trans)
      mutable_cell.addTransformation(trans_type, values);
  }
 
  // The join added the expanded cell to this root via root-merge; remove it so
  // replaceCellRefs() can place it in the correct universe(s)
  if (getRootUniverse().hasCell(expanded_cell.getName()))
    removeCellFromUniverse(getRootUniverse(), expanded_cell);
 
  // Replace all references to the CSGCellEngUnit in universes with the new expanded CSGCell
  replaceCellRefs(cast_ref<const CSGCell &>(mutable_unit), expanded_cell);
 
  // Remove the EngUnit (destroyed here, no more references to it after replaceCellRefs)
  deleteEngUnit(unit);
  return expanded_cell;
}

◆ expandEngUnit() [2/3]

CSGRegion CSG::CSGBase::expandEngUnit ( const CSGSurfaceEngUnit & unit )

Expand a surface-like engineering unit into basic CSGSurface(s) and return the CSGRegion representing the EngUnit's geometry.

Calls expandUnit() then calls getExpansionRegion() to obtain the combined CSGRegion. Every occurrence of the EngUnit as a surface reference in any existing cell region is replaced with the sub-region. The EngUnit is then removed from the engineering unit list and destroyed.

Parameters

unit	identifies the CSGSurfaceEngUnit to expand. Passed by const reference because the expansion does not mutate through this handle; it operates on and consumes the owned instance re-fetched from the surface list by name.

Returns: CSGRegion formed by the expanded CSGSurface(s)

Definition at line 1370 of file CSGBase.C.

{
  // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
  // reference to the same object from the owning surface list to perform the expansion, which
  // mutates and consumes the unit (expandUnit() is non-const).
  auto & mutable_unit = cast_ref<CSGSurfaceEngUnit &>(_surface_list.getSurface(unit.getName()));
 
  // Derived class creates the CSGSurface object(s) in the unit's base object and sets
  // _expanded_region
  mutable_unit.expandUnit();
 
  // check that the base object that was generated has only surfaces and no cells or universes
  // (except root).
  auto unit_base = mutable_unit.getBase();
  if ((unit_base.getAllCells().size() > 0) || (unit_base.getAllUniverses().size() > 1))
    mooseError("CSGSurfaceEngineering unit ",
               mutable_unit.getName(),
               " of type ",
               mutable_unit.getUnitType(),
               " contains either cells or universes (beyond the root universe) after expansion, "
               "but should only contain surfaces.");
 
  // Join the unit's base object into this; transfers surfaces (and any other objects) during merge.
  joinOtherBase(mutable_unit.releaseBase(), false);
 
  // Derived class provides the expanded region formed by the expanded surfaces
  CSGRegion expanded_region = mutable_unit.getExpandedRegion();
 
  // Propagate any stored transformations from the EngUnit to all new expanded surfaces
  const auto & trans = cast_ref<const CSGSurface &>(mutable_unit).getTransformations();
  if (!trans.empty())
    for (const auto & surf_ref : expanded_region.getSurfaces())
    {
      CSGSurface & mutable_surf = _surface_list.getSurface(surf_ref.get().getName());
      for (const auto & [trans_type, values] : trans)
        mutable_surf.addTransformation(trans_type, values);
    }
 
  // Replace every CSGSurfaceEngUnit reference in regions of CSGCells with the expanded sub-region
  replaceSurfaceRefsWithRegion(cast_ref<const CSGSurface &>(mutable_unit), expanded_region);
 
  // Remove the EngUnit (destroyed here, no more references to it after
  // replaceSurfaceRefsWithRegion)
  deleteEngUnit(unit);
  return expanded_region;
}

◆ expandEngUnit() [3/3]

const CSGUniverse & CSG::CSGBase::expandEngUnit ( const CSGUniverseEngUnit & unit )

Expand a universe-like engineering unit into a basic CSGUniverse.

Calls expandUnit() on the EngUnit to create the equivalent CSGUniverse and any necessary additional CSG components. All references to the original EngUnit in all cell fills, lattice universe maps/outers, and the root universe pointer are replaced with new CSGUniverse. The EngUnit is then removed from the engineering unit list and destroyed.

Parameters

unit	identifies the CSGUniverseEngUnit to expand. Passed by const reference because the expansion does not mutate through this handle; it operates on and consumes the owned instance re-fetched from the universe list by name.

Returns: const reference to the expanded CSGUniverse

Definition at line 1460 of file CSGBase.C.

{
  auto unit_name = unit.getName();
 
  // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
  // reference to the same object from the owning universe list to perform the expansion, which
  // mutates and consumes the unit (expandUnit() is non-const).
  auto & mutable_unit = cast_ref<CSGUniverseEngUnit &>(_universe_list.getUniverse(unit_name));
 
  // Derived class populates the unit's base object; the root of this base is the expanded universe
  // that will be used to replace this universe unit
  mutable_unit.expandUnit();
 
  // Capture the name of the expanded universe (the unit base's root universe) before the join
  // getExpandedUniverse will validate that the root contains cells and was properly
  // implemented/expanded such that incoming cells and universes are all linked to the root.
  auto & pre_join_univ = mutable_unit.getExpandedUniverse();
  auto expanded_name = pre_join_univ.getName();
 
  // Check that the expanded name for the new root universe has been updated to something other than
  // ROOT_UNIVERSE. If name was not already updated, issue a warning (debug) and update the name
  // automatically. This only matters if the current root universe is also named ROOT_UNIVERSE
  // so we only need to check if the name matches the root universe name (rather than explicitly
  // checking for the name ROOT_UNIVERSE).
 
  // release the incoming base object to be able to rename if necessary
  auto unit_base = mutable_unit.releaseBase();
  if (expanded_name == getRootUniverse().getName())
  {
    // root universe must be renamed
    auto new_expanded_name = unit_name + "_expanded_root";
#ifdef DEBUG
    mooseInfoRepeated("Universe engineering unit " + unit_name +
                      " has an expanded root universe named " + expanded_name +
                      ", which is identical to the name of the current root universe. The expanded "
                      "universe will be renamed " +
                      new_expanded_name + ".");
#endif
 
    unit_base->renameRootUniverse(new_expanded_name);
    expanded_name = new_expanded_name;
  }
 
  // Join the unit's base into this: all objects are transferred and the incoming root is added as
  // a named non-root universe (expanded_name). If the root universe's name is not unique (i.e. it
  // was left named ROOT_UNIVERSE), this will throw an error.
  joinOtherBase(std::move(unit_base), false, expanded_name);
 
  // must get this by name after joining because the join method rebuilds the universe and the
  // previous reference from getExpandedUniverse is not valid anymore.
  const CSGUniverse & expanded_univ = getUniverseByName(expanded_name);
 
  // Propagate any stored transformations from the EngUnit to the new expanded universe
  const auto & trans = cast_ref<const CSGUniverse &>(mutable_unit).getTransformations();
  if (!trans.empty())
  {
    CSGUniverse & mutable_univ = _universe_list.getUniverse(expanded_univ.getName());
    for (const auto & [trans_type, values] : trans)
      mutable_univ.addTransformation(trans_type, values);
  }
 
  // Replace references in cell fills, lattice maps and outers, and the root universe
  replaceUniverseRefs(cast_ref<const CSGUniverse &>(mutable_unit), expanded_univ);
 
  // Remove the EngUnit (destroyed here, no more references to it after replaceUniverseRefs)
  deleteEngUnit(unit);
  return expanded_univ;
}

◆ FRIEND_TEST() [1/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testAddGetSurface
	)

private

◆ FRIEND_TEST() [2/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testCellEngUnitAddErrors
	)

private

◆ FRIEND_TEST() [3/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testCheckRegionSurfaces
	)

private

Friends for unit testing.

◆ FRIEND_TEST() [4/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testEngUnitLinking
	)

private

◆ FRIEND_TEST() [5/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testUnivEngUnitAddErrors
	)

private

◆ FRIEND_TEST() [6/6]

CSG::CSGBase::FRIEND_TEST	(	CSGBaseTest	,
		testUniverseLinking
	)

private

◆ generateOutput()

nlohmann::json CSG::CSGBase::generateOutput ( ) const

generate the JSON representation output for the CSG object

Returns: nlohmann::json JSON object representing the CSG model

Definition at line 1590 of file CSGBase.C.

{
  // Check that orphaned universes do not exist in universe list of CSGBase object
  checkUniverseLinking();
 
  nlohmann::json csg_json;
 
  csg_json["surfaces"] = {};  // if empty (all are eng units), this will be deleted later
  csg_json["cells"] = {};     // if empty (all are eng units), this will be deleted later
  csg_json["universes"] = {}; // root universe always exists, so this does not get deleted later
 
  // get all surfaces information
  auto all_surfs = getAllSurfaces();
  for (const CSGSurface & s : all_surfs)
  {
    if (surfaceToEngUnit(s))
      continue; // engineering units are written in a separate section
    const auto & surf_name = s.getName();
    const auto & coeffs = s.getCoeffs();
    csg_json["surfaces"][surf_name] = {{"type", s.getSurfaceType()}, {"coefficients", {}}};
    for (const auto & c : coeffs)
      csg_json["surfaces"][surf_name]["coefficients"][c.first] = c.second;
    // include any information about transformations if present
    if (s.getTransformations().size() > 0)
      csg_json["surfaces"][surf_name]["transformations"] = s.getTransformationsAsStrings();
  }
 
  // Drop the surfaces section if nothing was written (e.g. all surfaces were engineering units,
  // which are output in the units section instead)
  if (csg_json["surfaces"].empty())
    csg_json.erase("surfaces");
 
  // Print out cell information
  auto all_cells = getAllCells();
  for (const CSGCell & c : all_cells)
  {
    if (cellToEngUnit(c))
      continue; // engineering units are written in a separate section
    const auto & cell_name = c.getName();
    const auto & cell_region_infix = c.getRegion().toInfixJSON();
    const auto & cell_region_postfix = c.getRegion().toPostfixStringList();
    const auto & cell_filltype = c.getFillType();
    const auto & fill_name = c.getFillName();
    csg_json["cells"][cell_name]["filltype"] = cell_filltype;
    csg_json["cells"][cell_name]["region_infix"] = cell_region_infix;
    csg_json["cells"][cell_name]["region_postfix"] = cell_region_postfix;
    csg_json["cells"][cell_name]["fill"] = fill_name;
    // include any information about transformations if present
    if (c.getTransformations().size())
      csg_json["cells"][cell_name]["transformations"] = c.getTransformationsAsStrings();
  }
 
  // Drop the cells section if nothing was written (e.g. all cells were engineering units,
  // which are output in the units section instead)
  if (csg_json["cells"].empty())
    csg_json.erase("cells");
 
  // Print out universe information
  auto all_univs = getAllUniverses();
  for (const CSGUniverse & u : all_univs)
  {
    if (universeToEngUnit(u))
      continue; // engineering units are written in a separate section
    const auto & univ_name = u.getName();
    const auto & univ_cells = u.getAllCells();
    csg_json["universes"][univ_name]["cells"] = {};
    for (const CSGCell & c : univ_cells)
      csg_json["universes"][univ_name]["cells"].push_back(c.getName());
    if (u.isRoot())
      csg_json["universes"][univ_name]["root"] = u.isRoot();
    // include any information about transformations if present
    if (u.getTransformations().size())
      csg_json["universes"][univ_name]["transformations"] = u.getTransformationsAsStrings();
  }
 
  // print out lattice information if lattices exist
  auto all_lats = getAllLattices();
  if (all_lats.size())
  {
    csg_json["lattices"] = {};
    for (const CSGLattice & lat : all_lats)
    {
      const auto & lat_name = lat.getName();
      csg_json["lattices"][lat_name] = {};
      csg_json["lattices"][lat_name]["type"] = lat.getType();
      const auto & outer_type = lat.getOuterType();
      csg_json["lattices"][lat_name]["outertype"] = outer_type;
      if (outer_type == "UNIVERSE")
        csg_json["lattices"][lat_name]["outer"] = lat.getOuterUniverse().getName();
      else if (outer_type == "CSG_MATERIAL")
        csg_json["lattices"][lat_name]["outer"] = lat.getOuterMaterial();
      // write out any additional attributes
      csg_json["lattices"][lat_name]["attributes"] = {};
      const auto & lat_attrs = lat.getAttributes();
      for (const auto & attr : lat_attrs)
        csg_json["lattices"][lat_name]["attributes"][attr.first] = attr.second;
      // write the map of universe names: list of lists
      csg_json["lattices"][lat_name]["universes"] = lat.getUniverseNameMap();
      // include any information about transformations if present
      if (lat.getTransformations().size())
        csg_json["lattices"][lat_name]["transformations"] = lat.getTransformationsAsStrings();
    }
  }
 
  // include engineering units if they exist
  auto all_units = getAllEngUnits();
  if (all_units.size())
  {
    csg_json["units"] = {};
    for (const CSGEngUnit & unit : all_units)
    {
      const auto & unit_name = unit.getName();
      csg_json["units"][unit_name] = {};
      // behavior and type
      csg_json["units"][unit_name]["unit_type"] = unit.getUnitType();
      csg_json["units"][unit_name]["behavior"] = unit.getBehavior();
      // any unit-specific attributes
      csg_json["units"][unit_name]["attributes"] = {};
      const auto & unit_attrs = unit.getAttributes();
      for (const auto & attr : unit_attrs)
        csg_json["units"][unit_name]["attributes"][attr.first] = attr.second;
      if (unit.getTransformations().size())
        csg_json["units"][unit_name]["transformations"] = unit.getTransformationsAsStrings();
    }
  }
 
  return csg_json;
}

◆ getAllCellEngUnits()

std::vector< std::reference_wrapper< const CSGCellEngUnit > > CSG::CSGBase::getAllCellEngUnits ( ) const

inline

Get all cell-like engineering units in CSGBase.

Returns: list of const references to all CSGCellEngUnit objects

Definition at line 649 of file CSGBase.h.

  {
    return _eng_unit_list.getAllCellEngUnits();
  }

Referenced by CSGBase().

◆ getAllCells()

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

inline

Get all cell objects.

Returns: list of references to all CSGCell objects in CSGBase

Definition at line 204 of file CSGBase.h.

  {
    return _cell_list.getAllCells();
  }

◆ getAllEngUnits()

std::vector< std::reference_wrapper< const CSGEngUnit > > CSG::CSGBase::getAllEngUnits ( ) const

inline

Get all engineering units of all types in CSGBase.

Returns: list of const references to all CSGEngUnit objects

Definition at line 629 of file CSGBase.h.

  {
    return _eng_unit_list.getAllEngUnits();
  }

◆ getAllLattices()

std::vector< std::reference_wrapper< const CSGLattice > > CSG::CSGBase::getAllLattices ( ) const

inline

Get all lattice objects.

Returns: list of references to CSGLattice objects in this CSGBase instance

Definition at line 491 of file CSGBase.h.

  {
    return _lattice_list.getAllLattices();
  }

◆ getAllSurfaceEngUnits()

std::vector< std::reference_wrapper< const CSGSurfaceEngUnit > > CSG::CSGBase::getAllSurfaceEngUnits ( ) const

inline

Get all surface-like engineering units in CSGBase.

Returns: list of const references to all CSGSurfaceEngUnit objects

Definition at line 639 of file CSGBase.h.

  {
    return _eng_unit_list.getAllSurfaceEngUnits();
  }

◆ getAllSurfaces()

std::vector< std::reference_wrapper< const CSGSurface > > CSG::CSGBase::getAllSurfaces ( ) const

inline

Get all surface objects.

Returns: list of references to all CSGSurface objects in CSGBase

Definition at line 101 of file CSGBase.h.

  {
    return _surface_list.getAllSurfaces();
  }

◆ getAllUniverseEngUnits()

std::vector< std::reference_wrapper< const CSGUniverseEngUnit > > CSG::CSGBase::getAllUniverseEngUnits ( ) const

inline

Get all universe-like engineering units.

Returns: list of const references to all CSGUniverseEngUnit objects

Definition at line 659 of file CSGBase.h.

  {
    return _eng_unit_list.getAllUniverseEngUnits();
  }

Referenced by CSGBase().

◆ getAllUniverses()

std::vector< std::reference_wrapper< const CSGUniverse > > CSG::CSGBase::getAllUniverses ( ) const

inline

Get all universe objects.

Returns: list of references to CSGUniverse objects in this CSGBase instance

Definition at line 365 of file CSGBase.h.

  {
    return _universe_list.getAllUniverses();
  }

◆ getCellByName()

const CSGCell & CSG::CSGBase::getCellByName ( const std::string & name ) const

inline

Get a Cell object by name.

Parameters

name cell name

Returns: reference to CSGCell object

Definition at line 215 of file CSGBase.h.

215{ return _cell_list.getCell(name); }

◆ getCellList() [1/2]

CSGCellList & CSG::CSGBase::getCellList ( )

inlineprivate

Get a non-const reference to the CSGCellList object.

Returns: CSGCellList

Definition at line 993 of file CSGBase.h.

993{ return _cell_list; }

◆ getCellList() [2/2]

const CSGCellList & CSG::CSGBase::getCellList ( ) const

inlineprivate

Get a const reference to the CSGCellList object.

Returns: CSGCellList

Definition at line 986 of file CSGBase.h.

986{ return _cell_list; }

Referenced by CSGBase(), operator==(), replaceLatticeRefsByName(), replaceSurfaceRefsByName(), and replaceUniverseRefsByName().

◆ getEngUnitByName()

template<typename EngUnitType = CSGEngUnit>

const EngUnitType & CSG::CSGBase::getEngUnitByName ( const std::string & name ) const

inline

Get a engineering unit object of the specified type by name.

This is a templated method with a default type of CSGEngUnit. If a specific unit type is needed, it can be specified when calling. If the type is unknown or not specified, it will default to CSGEngUnit to get the base class reference. NOTE: if CSGEngUnit is used as the template type, any type-specific attributes or methods may not be accessible, except using a reference cast.

Parameters

name	engineering unit name

Returns: const reference to the engineering unit

Definition at line 597 of file CSGBase.h.

  {
    const CSGEngUnit & unit = _eng_unit_list.getEngUnit(name);
    const EngUnitType * typed_unit = dynamic_cast<const EngUnitType *>(&unit);
    if (!typed_unit)
      mooseError("Cannot get engineering unit " + name +
                 ". Engineering unit is not of specified type " +
                 MooseUtils::prettyCppType<EngUnitType>());
    return *typed_unit;
  }

◆ getEngUnitList()

const CSGEngUnitList & CSG::CSGBase::getEngUnitList ( ) const

inlineprivate

Get a const reference to the CSGEngUnitList object.

Returns: CSGEngUnitList

Definition at line 1086 of file CSGBase.h.

1086{ return _eng_unit_list; }

Referenced by operator==().

◆ getLatticeByName()

template<typename LatticeType = CSGLattice>

const LatticeType & CSG::CSGBase::getLatticeByName ( const std::string & name )

inline

Get a lattice object of the specified type by name.

This is a templated method with a default type of CSGLattice. If a specific lattice type is needed, it can be specified when calling. If the type is unknown or not specified, it will default to CSGLattice to get the base class reference. NOTE: if CSGLattice is used as the template type, any lattice type-specific attributes or methods may not be accessible, except using a reference cast.

Parameters

name	lattice name

Returns: reference to CSGLattice object

Definition at line 509 of file CSGBase.h.

  {
    const CSGLattice & lattice = _lattice_list.getLattice(name);
    const LatticeType * typed_lattice = dynamic_cast<const LatticeType *>(&lattice);
    if (!typed_lattice)
      mooseError("Cannot get lattice " + name + ". Lattice is not of specified type " +
                 MooseUtils::prettyCppType<LatticeType>());
    return *typed_lattice;
  }

◆ getLatticeList() [1/2]

CSGLatticeList & CSG::CSGBase::getLatticeList ( )

inlineprivate

Get the CSGLatticeList object.

Returns: CSGLatticeList

Definition at line 1021 of file CSGBase.h.

1021{ return _lattice_list; }

◆ getLatticeList() [2/2]

const CSGLatticeList & CSG::CSGBase::getLatticeList ( ) const

inlineprivate

Get a const reference to the CSGLatticeList object.

Returns: CSGLatticeList

Definition at line 1014 of file CSGBase.h.

1014{ return _lattice_list; }

Referenced by CSGBase(), operator==(), and replaceUniverseRefsByName().

◆ getLinkedCSGObjects()

void CSG::CSGBase::getLinkedCSGObjects	(	const CSGUniverse &	univ,
		std::set< std::string > &	linked_universe_names,
		std::set< std::string > &	linked_cell_names,
		std::set< std::string > &	linked_surface_names
	)		const

private

Recursive method to retrieve all universes, cells, and surfaces linked to current universe.

Parameters

univ	Reference to universe under consideration
linked_universe_names	List of universe names linked to current universe
linked_cell_names	List of cell names linked to current universe
linked_surface_names	List of surface names linked to current universe

Definition at line 1257 of file CSGBase.C.

{
  linked_universe_names.insert(univ.getName());
  const auto & univ_cells = univ.getAllCells();
  for (const CSGCell & cell : univ_cells)
  {
    linked_cell_names.insert(cell.getName());
    for (const CSGSurface & cell_surf : cell.getRegion().getSurfaces())
      linked_surface_names.insert(cell_surf.getName());
 
    if (cell.getFillType() == "UNIVERSE")
      getLinkedCSGObjects(
          cell.getFillUniverse(), linked_universe_names, linked_cell_names, linked_surface_names);
    else if (cell.getFillType() == "LATTICE")
    {
      const auto & lattice = cell.getFillLattice();
      for (const auto & univ_list : lattice.getUniverses())
        for (const auto & univ_ref : univ_list)
        {
          const CSGUniverse & lattice_univ = univ_ref.get();
          getLinkedCSGObjects(
              lattice_univ, linked_universe_names, linked_cell_names, linked_surface_names);
        }
 
      if (lattice.getOuterType() == "UNIVERSE")
      {
        const CSGUniverse & outer_univ = lattice.getOuterUniverse();
        getLinkedCSGObjects(
            outer_univ, linked_universe_names, linked_cell_names, linked_surface_names);
      }
    }
  }
}

◆ getRootUniverse()

const CSGUniverse & CSG::CSGBase::getRootUniverse ( ) const

inline

Get the Root Universe object.

Returns: reference to root CSGUniverse

Definition at line 277 of file CSGBase.h.

277{ return _universe_list.getRoot(); }

CSG::CSGUniverseList::getRoot

const CSGUniverse & getRoot() const

Get the root universe.

Definition CSGUniverseList.h:92

Referenced by addEngUnit(), and CSGBase().

◆ getSurface()

CSGSurface & CSG::CSGBase::getSurface ( const std::string & name )

inlineprivate

Get a Surface object by name.

Note: This is a private method that returns a non-const reference. For the public method that returns a const reference, use getSurfaceByName

Parameters

name	surface name

Returns: reference to CSGSurface object

Definition at line 936 of file CSGBase.h.

936{ return _surface_list.getSurface(name); }

◆ getSurfaceByName()

const CSGSurface & CSG::CSGBase::getSurfaceByName ( const std::string & name ) const

inline

Get a Surface object by name.

Parameters

name	surface name

Returns: reference to CSGSurface object

Definition at line 112 of file CSGBase.h.

  {
    return _surface_list.getSurface(name);
  }

◆ getSurfaceList() [1/2]

CSGSurfaceList & CSG::CSGBase::getSurfaceList ( )

inlineprivate

Get a non-const reference to the CSGSurfaceList object.

Returns: CSGSurfaceList

Definition at line 979 of file CSGBase.h.

979{ return _surface_list; }

◆ getSurfaceList() [2/2]

const CSGSurfaceList & CSG::CSGBase::getSurfaceList ( ) const

inlineprivate

Get a const reference to the CSGSurfaceList object.

Returns: CSGSurfaceList

Definition at line 972 of file CSGBase.h.

972{ return _surface_list; }

Referenced by operator==(), and updateIncomingCSGReferences().

◆ getUniverseByName()

const CSGUniverse & CSG::CSGBase::getUniverseByName ( const std::string & name )

inline

Get a universe object by name.

Parameters

name	universe name

Returns: reference to CSGUniverse object

Definition at line 376 of file CSGBase.h.

  {
    return _universe_list.getUniverse(name);
  }

◆ getUniverseList() [1/2]

CSGUniverseList & CSG::CSGBase::getUniverseList ( )

inlineprivate

Get a non-const reference to the CSGUniverseList object.

Returns: CSGUniverseList

Definition at line 1007 of file CSGBase.h.

1007{ return _universe_list; }

◆ getUniverseList() [2/2]

const CSGUniverseList & CSG::CSGBase::getUniverseList ( ) const

inlineprivate

Get a const reference to the CSGUniverseList object.

Returns: CSGUniverseList

Definition at line 1000 of file CSGBase.h.

1000{ return _universe_list; }

Referenced by CSGBase(), operator==(), and replaceCellRefsByName().

◆ hasCell()

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

inline

Check if a cell with given name exists in CSGBase object.

Parameters

name cell name

Returns: true if cell with given name exists in CSGBase

Definition at line 223 of file CSGBase.h.

223{ return _cell_list.hasCell(name); }

◆ hasEngUnit()

bool CSG::CSGBase::hasEngUnit ( const std::string & name ) const

inline

Check if an engineeering unit with given name exists in CSGBase object.

Parameters

name	engineering unit name

Returns: Check if an engineering unit with given name exists in CSGBase object

Definition at line 614 of file CSGBase.h.

614{ return _eng_unit_list.hasEngUnit(name); }

◆ hasLattice()

bool CSG::CSGBase::hasLattice ( const std::string & name ) const

inline

Check if a lattice with given name exists in CSGBase object.

Parameters

name	lattice name

Returns: true if lattice with given name exists in CSGBase

Definition at line 525 of file CSGBase.h.

525{ return _lattice_list.hasLattice(name); }

◆ hasSurface()

bool CSG::CSGBase::hasSurface ( const std::string & name ) const

inline

Check if a surface with given name exists in CSGBase object.

Parameters

name	surface name

Returns: true if surface with given name exists in CSGBase

Definition at line 123 of file CSGBase.h.

123{ return _surface_list.hasSurface(name); }

CSG::CSGSurfaceList::hasSurface

bool hasSurface(const std::string &name) const

return whether surface with given name exists in surface list

Definition CSGSurfaceList.h:71

◆ hasUniverse()

bool CSG::CSGBase::hasUniverse ( const std::string & name ) const

inline

Check if a universe with given name exists in CSGBase object.

Parameters

name	universe name

Returns: true if universe with given name exists in CSGBase

Definition at line 387 of file CSGBase.h.

387{ return _universe_list.hasUniverse(name); }

◆ joinCellList()

void CSG::CSGBase::joinCellList	(	CSGCellList &	cell_list,
		const bool	ignore_identical_cells
	)

private

join a separate CSGCellList object to this one

Parameters

cell_list	CSGCellList from a separate CSGBase object
ignore_identical_cells	if true, will skip adding identical cells to the CSGBase object

Definition at line 981 of file CSGBase.C.

{
  auto & cell_list_map = cell_list.getCellListMap();
  for (auto & c : cell_list_map)
    _cell_list.addCell(std::move(c.second), ignore_identical_cells);
}

◆ joinLatticeList()

void CSG::CSGBase::joinLatticeList	(	CSGLatticeList &	lattice_list,
		const bool	ignore_identical_lattices
	)

private

join a separate CSGLatticeList object to this one

Parameters

lattice_list	CSGLatticeList from a separate CSGBase object
ignore_identical_lattices	if true, will skip adding identical lattices to the CSGBase object

Definition at line 989 of file CSGBase.C.

{
  auto & lat_list_map = lattice_list.getLatticeListMap();
  for (auto & lat : lat_list_map)
    _lattice_list.addLattice(std::move(lat.second), ignore_identical_lattices);
}

◆ joinOtherBase() [1/3]

void CSG::CSGBase::joinOtherBase	(	std::unique_ptr< CSGBase >	base,
		const bool	ignore_identical_components
	)

Join another CSGBase object to this one.

The cells of the root universe of the incoming CSGBase will be added to the existing root universe of this CSGBase.

Parameters

base	pointer to a different CSGBase object
ignore_identical_components	if true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object

Definition at line 791 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(base->getUniverseList(), ignore_identical_components);
  rebuildEngUnitList(); // finds all engineering units again, allowing us to keep any ignored
                        // surfaces that were removed from the surface list out of this list
}

◆ joinOtherBase() [2/3]

void CSG::CSGBase::joinOtherBase	(	std::unique_ptr< CSGBase >	base,
		const bool	ignore_identical_components,
		const std::string &	new_root_name_base,
		const std::string &	new_root_name_join
	)

Join another CSGBase object to this one.

The root universe for the incoming CSGBase object is added to this CSGBase object as a non-root universe with a new name. The root universe of this CSGBase object will be renamed and designated as non-root. Note: upon completion of this join method, the root universe of this CSGBase object will be empty. Neither of the new non-root universes will be connected to the new root universe by default.

Parameters

base	pointer to a different CSGBase object
ignore_identical_components	if true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object
new_root_name_base	new name for universe generated from this root universe
new_root_name_join	new name for the universe generated from the incoming root universe

Definition at line 823 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(
      base->getUniverseList(), ignore_identical_components, new_root_name_base, new_root_name_join);
  rebuildEngUnitList(); // finds all engineering units again, allowing us to keep any ignored
                        // surfaces that were removed from the surface list out of this list
}

◆ joinOtherBase() [3/3]

void CSG::CSGBase::joinOtherBase	(	std::unique_ptr< CSGBase >	base,
		const bool	ignore_identical_components,
		const std::string &	new_root_name_join
	)

Join another CSGBase object to this one.

For the incoming CSGBase object, the root universe is added to this CSGBase object as a new non-root universe with the specified new name. Note: this newly created universe will not be connected to the root universe of this CSGBase object by default.

Parameters

base	pointer to a different CSGBase object
ignore_identical_components	if true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object
new_root_name_join	new name for the universe generated from the incoming root universe

Definition at line 806 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(base->getUniverseList(), ignore_identical_components, new_root_name_join);
  rebuildEngUnitList(); // finds all engineering units again, allowing us to keep any ignored
                        // surfaces that were removed from the surface list out of this list
}

◆ joinSurfaceList()

void CSG::CSGBase::joinSurfaceList	(	CSGSurfaceList &	surf_list,
		const bool	ignore_identical_surfaces
	)

private

join a separate CSGSurfaceList object to this one

Parameters

surf_list	CSGSurfaceList from a separate CSGBase object
ignore_identical_surfaces	if true, will skip adding identical surfaces to the CSGBase object

Definition at line 973 of file CSGBase.C.

{
  auto & surf_list_map = surf_list.getSurfaceListMap();
  for (auto & s : surf_list_map)
    _surface_list.addSurface(std::move(s.second), ignore_identical_surfaces);
}

◆ joinUniverseList() [1/3]

void CSG::CSGBase::joinUniverseList	(	CSGUniverseList &	univ_list,
		const bool	ignore_identical_universes
	)

private

join a separate CSGUniverseList object to this one; root universes from univ_list will be combined into this root universe

Parameters

univ_list	CSGUniverseList from a separate CSGBase object
ignore_identical_universes	if true, will skip adding identical universes to the CSGBase object

Definition at line 1015 of file CSGBase.C.

{
  // case 1: incoming root is joined into existing root; no new universes are created
  auto & univ_list_map = univ_list.getUniverseListMap();
  auto & root = getRootUniverse(); // this root universe
  for (auto & u : univ_list_map)
  {
    if (u.second->isRoot())
    {
      // add existing cells to current root instead of creating new universe
      auto all_cells = u.second->getAllCells();
      for (auto & cell : all_cells)
        addCellToUniverse(root, cell);
    }
    else // unique non-root universe to add to list
      _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
  }
}

◆ joinUniverseList() [2/3]

void CSG::CSGBase::joinUniverseList	(	CSGUniverseList &	univ_list,
		const bool	ignore_identical_universes,
		const std::string &	new_root_name_base,
		const std::string &	new_root_name_incoming
	)

private

join a separate CSGUniverseList object to this one; both this root universe and the incoming root universe will be maintained as separate universes of the specified names.

Note: upon completion of this join method, the root universe will be empty.

Parameters

univ_list	CSGUniverseList from a separate CSGBase object
ignore_identical_universes	if true, will skip adding identical lattices to the CSGBase object
new_root_name_base	new name for universe generated from this root universe
new_root_name_incoming	new name for the universe generated from the incoming root universe

Definition at line 1057 of file CSGBase.C.

{
  // case 3: each root universe becomes a new universe and a new root is created
 
  // make a new universe from the existing root universe
  auto & root = getRootUniverse();
  auto root_cells = root.getAllCells();
  createUniverse(new_root_name_base, root_cells);
  removeCellsFromUniverse(root, root_cells);
 
  // add incoming universes to current Base
  auto & all_univs = univ_list.getUniverseListMap();
  for (auto & u : all_univs)
  {
    if (u.second->isRoot())
    {
      // create new universe from incoming root universe
      auto all_cells = u.second->getAllCells();
      createUniverse(new_root_name_incoming, all_cells);
    }
    else // unique non-root universe to add to list
      _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
  }
}

◆ joinUniverseList() [3/3]

void CSG::CSGBase::joinUniverseList	(	CSGUniverseList &	univ_list,
		const bool	ignore_identical_universes,
		const std::string &	new_root_name_incoming
	)

private

join a separate CSGUniverseList object to this one; the incoming root universe will be moved to a new universe of the new name specified.

Parameters

univ_list	CSGUniverseList from a separate CSGBase object
ignore_identical_universes	if true, will skip adding identical universes to the CSGBase object
new_root_name_incoming	new name for the universe generated from the incoming root universe

Definition at line 1035 of file CSGBase.C.

{
  // case 2: incoming root is turned into new universe and existing root remains root
 
  // add incoming universes to current Base
  auto & all_univs = univ_list.getUniverseListMap();
  for (auto & u : all_univs)
  {
    if (u.second->isRoot())
    {
      // create new universe from incoming root universe
      auto all_cells = u.second->getAllCells();
      createUniverse(new_root_name_incoming, all_cells);
    }
    else // unique non-root universe to add to list
      _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
  }
}

◆ operator!=()

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

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

Definition at line 1738 of file CSGBase.C.

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

◆ operator==()

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

Operator overload for checking if two CSGBase objects are equal.

Definition at line 1720 of file CSGBase.C.

{
  const auto & surf_list = this->getSurfaceList();
  const auto & other_surf_list = other.getSurfaceList();
  const auto & cell_list = this->getCellList();
  const auto & other_cell_list = other.getCellList();
  const auto & univ_list = this->getUniverseList();
  const auto & other_univ_list = other.getUniverseList();
  const auto & lat_list = this->getLatticeList();
  const auto & other_lat_list = other.getLatticeList();
  const auto & eng_unit_list = this->getEngUnitList();
  const auto & other_eng_unit_list = other.getEngUnitList();
  return (surf_list == other_surf_list) && (cell_list == other_cell_list) &&
         (univ_list == other_univ_list) && (lat_list == other_lat_list) &&
         (eng_unit_list == other_eng_unit_list);
}

◆ prepareCellDeletion()

void CSG::CSGBase::prepareCellDeletion ( const CSGCell & cell )

private

warn and remove cell from any universe that contains it

Definition at line 339 of file CSGBase.C.

{
  for (const auto & univ_ref : _universe_list.getAllUniverses())
  {
    const auto & univ = univ_ref.get();
    for (const auto & univ_cell : univ.getAllCells())
      if (cell == univ_cell.get())
      {
        // must remove from root intentionally too, but don't warn in this case (too noisy for
        // expected behavior)
        if (univ != getRootUniverse())
          mooseWarning("Removing cell ",
                       cell.getName(),
                       " from universe with name ",
                       univ.getName(),
                       " before cell deletion.");
        _universe_list.getUniverse(univ.getName()).removeCell(cell.getName());
      }
  }
}

◆ prepareSurfaceDeletion()

void CSG::CSGBase::prepareSurfaceDeletion ( const CSGSurface & surface ) const

private

error if surface is referenced in any cell region

Definition at line 106 of file CSGBase.C.

{
  for (const auto & cell_ref : _cell_list.getAllCells())
  {
    const auto & cell = cell_ref.get();
    for (const auto & region_surf : cell.getRegion().getSurfaces())
      if (region_surf.get() == surface)
        mooseError("Cannot delete surface with name ",
                   surface.getName(),
                   " as it is used in region definition of cell with name ",
                   cell.getName());
  }
}

◆ prepareUniverseDeletion()

void CSG::CSGBase::prepareUniverseDeletion ( const CSGUniverse & universe ) const

private

error if universe is the root, used in any lattice, or used as a cell fill

Definition at line 476 of file CSGBase.C.

{
  if (univ == getRootUniverse())
    mooseError("Cannot delete root universe from CSGBase instance");
 
  // Check if universe is used in any existing lattices
  for (const auto & lat : _lattice_list.getAllLattices())
  {
    for (const auto & lat_univ : lat.get().getUniqueUniverses())
      if (univ == lat_univ.get())
        mooseError("Cannot delete universe with name ",
                   univ.getName(),
                   " as it is used in lattice with name ",
                   lat.get().getName());
    if ((lat.get().getOuterType() == "UNIVERSE") && (lat.get().getOuterUniverse() == univ))
      mooseError("Cannot delete universe with name ",
                 univ.getName(),
                 " as it is used as the outer universe of lattice with name ",
                 lat.get().getName());
  }
 
  // Check if universe is used as fill in existing cells
  for (const auto & cell_ref : _cell_list.getAllCells())
  {
    const auto & cell = cell_ref.get();
    if ((cell.getFillType() == "UNIVERSE") && (cell.getFillUniverse() == univ))
      mooseError("Cannot delete universe with name ",
                 univ.getName(),
                 " as it is used as the fill of cell with name ",
                 cell.getName());
  }
}

◆ rebuildEngUnitList()

void CSG::CSGBase::rebuildEngUnitList ( )

private

rebuilds the list of raw pointers to engineering units by iterating through the surface, cell, and universe lists.

Definition at line 997 of file CSGBase.C.

{
  _eng_unit_list = CSGEngUnitList(); // reset to empty
 
  // iterate through all existing lists to find all CSGEngUnit types and store the pointers to the
  // rebuilt engineering unit list
  for (auto & [name, surf] : _surface_list.getSurfaceListMap())
    if (auto * eu = dynamic_cast<CSGSurfaceEngUnit *>(surf.get()))
      _eng_unit_list.addEngUnit(*eu);
  for (auto & [name, cell] : _cell_list.getCellListMap())
    if (auto * eu = dynamic_cast<CSGCellEngUnit *>(cell.get()))
      _eng_unit_list.addEngUnit(*eu);
  for (auto & [name, univ] : _universe_list.getUniverseListMap())
    if (auto * eu = dynamic_cast<CSGUniverseEngUnit *>(univ.get()))
      _eng_unit_list.addEngUnit(*eu);
}

Referenced by CSGBase().

◆ removeCellFromUniverse()

void CSG::CSGBase::removeCellFromUniverse	(	const CSGUniverse &	universe,
		const CSGCell &	cell
	)

Remove a cell from an existing universe.

Parameters

universe	universe from which to remove the cell
cell	cell to remove

Definition at line 555 of file CSGBase.C.

{
  // make sure cell is a part of this CSGBase instance
  if (!checkCellInBase(cell))
    mooseError("A cell named " + cell.getName() + " is being removed from universe " +
               universe.getName() +
               " that is different from the cell of the same name in the CSGBase instance.");
  // make sure universe is a part of this CSGBase instance
  if (!checkUniverseInBase(universe))
    mooseError("Cells are being removed from a universe named " + universe.getName() +
               " that is different " +
               "from the universe of the same name in the CSGBase instance.");
  auto & univ = _universe_list.getUniverse(universe.getName());
  // removeCell will produce error that cell is not found in the case that the universe is actually
  // an engineering unit, so we don't need to check that.
  univ.removeCell(cell.getName());
}

◆ removeCellsFromUniverse()

void CSG::CSGBase::removeCellsFromUniverse	(	const CSGUniverse &	universe,
		std::vector< std::reference_wrapper< const CSGCell > > &	cells
	)

Remove a list of cells from an existing universe.

Parameters

universe	universe from which to remove the cells
cells	list of references to cells to remove

Definition at line 574 of file CSGBase.C.

{
  for (auto & c : cells)
    removeCellFromUniverse(universe, c);
}

◆ renameCell()

void CSG::CSGBase::renameCell	(	const CSGCell &	cell,
		const std::string &	name
	)

rename the specified cell

Parameters

cell	reference to CSGCell to rename
name	new name

Definition at line 1179 of file CSGBase.C.

{
  // if cell is actually an engineering unit, we have to also check that no other units have the
  // same name already
  if (cellToEngUnit(cell))
    if (_eng_unit_list.hasEngUnit(name))
      mooseError("Cannot rename cell " + cell.getName() + " to " + name + ". " + cell.getName() +
                 " is an engineering unit and a unit with name " + name + " already exists.");
 
  _cell_list.renameCell(cell, name);
}

◆ renameEngUnit()

void CSG::CSGBase::renameEngUnit	(	const CSGEngUnit &	unit,
		const std::string &	name
	)

Rename the specified engineering unit.

Parameters

unit	reference to engineering unit to rename
name	new name

Definition at line 1148 of file CSGBase.C.

{
  // Rename in the owning type list (updates the object's name and the type list map key).
  // The EngUnit index stores raw pointers; because the object's name is updated in-place,
  // no index update is needed.
  if (const auto * surf = dynamic_cast<const CSGSurfaceEngUnit *>(&unit))
    renameSurface(*surf, name);
  else if (const auto * cell = dynamic_cast<const CSGCellEngUnit *>(&unit))
    renameCell(*cell, name);
  else if (const auto * univ = dynamic_cast<const CSGUniverseEngUnit *>(&unit))
    renameUniverse(*univ, name);
  else
    mooseError(
        "Engineering unit '", unit.getName(), "' has an unrecognized type and cannot be renamed.");
}

◆ renameLattice()

void CSG::CSGBase::renameLattice	(	const CSGLattice &	lattice,
		const std::string &	name
	)

inline

rename the lattice

Parameters

lattice	lattice to rename
name	new name

Definition at line 456 of file CSGBase.h.

  {
    _lattice_list.renameLattice(lattice, name);
  }

◆ renameRootUniverse()

void CSG::CSGBase::renameRootUniverse ( const std::string & name )

inline

rename the root universe for this instance (default is ROOT_UNIVERSE)

Parameters

name	new name for the root universe

Definition at line 284 of file CSGBase.h.

  {
    renameUniverse(_universe_list.getRoot(), name);
  }

◆ renameSurface()

void CSG::CSGBase::renameSurface	(	const CSGSurface &	surface,
		const std::string &	name
	)

rename the specified surface

Parameters

surface	CSGSurface to rename
name	new name

Definition at line 1165 of file CSGBase.C.

{
  // if surface is actually an engineering unit, we have to also check that no other units have the
  // same name already
  if (surfaceToEngUnit(surface))
    if (_eng_unit_list.hasEngUnit(name))
      mooseError("Cannot rename surface " + surface.getName() + " to " + name + ". " +
                 surface.getName() + " is an engineering unit and a unit with name " + name +
                 " already exists.");
 
  _surface_list.renameSurface(surface, name);
}

◆ renameUniverse()

void CSG::CSGBase::renameUniverse	(	const CSGUniverse &	universe,
		const std::string &	name
	)

rename the specified universe

Parameters

universe	reference to CSGUniverse to rename
name	new name

Definition at line 1192 of file CSGBase.C.

{
  // if universe is actually an engineering unit, we have to also check that no other units have the
  // same name already
  if (universeToEngUnit(universe))
    if (_eng_unit_list.hasEngUnit(name))
      mooseError("Cannot rename universe " + universe.getName() + " to " + name + ". " +
                 universe.getName() + " is an engineering unit and a unit with name " + name +
                 " already exists.");
 
  _universe_list.renameUniverse(universe, name);
}

Referenced by renameRootUniverse().

◆ replaceCellRefs()

void CSG::CSGBase::replaceCellRefs	(	const CSGCell &	old_cell,
		const CSGCell &	new_cell
	)

private

Replace all old_cell references with new_cell across all universes in the base.

Definition at line 1560 of file CSGBase.C.

{
  for (const auto & univ_ref : getAllUniverses())
  {
    const CSGUniverse & univ = univ_ref.get();
    for (const auto & cell_ref : univ.getAllCells())
      if (&cell_ref.get() == &old_cell)
      {
        removeCellFromUniverse(univ, old_cell);
        addCellToUniverse(univ, new_cell);
      }
  }
}

◆ replaceCellRefsByName()

void CSG::CSGBase::replaceCellRefsByName	(	std::map< std::string, std::reference_wrapper< const CSGCell > > &	identical_cell_refs,
		CSGBase &	base
	)

private

update cell references of incoming CSGbase to point to those of existing CSGBase object based on CSGCell name.

This involves updating the cell references of universes.

Parameters

identical_cell_refs	map of cell names to cell references that will be used for replacement
base	CSGBase object that contains references that should be updated

Definition at line 902 of file CSGBase.C.

{
  // Update cell references of universes to those of this base
  for (auto & [univ_name, univ_ptr] : base.getUniverseList().getUniverseListMap())
    for (auto & [cell_name, cell_ref] : identical_cell_refs)
      if (univ_ptr->hasCell(cell_name))
      {
        univ_ptr->removeCell(cell_name);
        univ_ptr->addCell(cell_ref);
      }
}

◆ replaceLatticeRefsByName()

void CSG::CSGBase::replaceLatticeRefsByName	(	std::map< std::string, std::reference_wrapper< const CSGLattice > > &	identical_lattice_refs,
		CSGBase &	base
	)

private

update lattice references of incoming CSGbase to point to those of existing CSGBase object based on CSGLattice name.

This involves updating the lattice references of cells.

Parameters

identical_lattice_refs	map of lattice names to lattice references that will be used for replacement
base	CSGBase object that contains references that should be updated

Definition at line 954 of file CSGBase.C.

{
  // Update lattice references of cells to those of this base
  for (auto & [cell_name, cell_ptr] : base.getCellList().getCellListMap())
  {
    const auto fill_type = cell_ptr->getFillType();
    const auto fill_name = cell_ptr->getFillName();
    if ((fill_type == "LATTICE") &&
        (identical_lattice_refs.find(fill_name) != identical_lattice_refs.end()))
    {
      const CSGLattice * lat_ptr = &identical_lattice_refs.at(fill_name).get();
      cell_ptr->updateCellFill(lat_ptr);
    }
  }
}

◆ replaceSurfaceRefsByName()

void CSG::CSGBase::replaceSurfaceRefsByName	(	std::map< std::string, std::reference_wrapper< const CSGSurface > > &	identical_surface_refs,
		CSGBase &	base
	)

private

update surface references of incoming CSGBase to point to those of existing CSGBase object based on CSGSurface name.

This involves updating the surface references of cell regions.

Parameters

identical_surface_refs	map of surface names to surface references that will be used for replacement
base	CSGBase object that contains references that should be updated

Definition at line 892 of file CSGBase.C.

{
  // Update surface references of cell regions to those of this base
  for (auto & [cell_name, cell_ptr] : base.getCellList().getCellListMap())
    cell_ptr->updateCellRegionSurfaces(identical_surface_refs);
}

◆ replaceSurfaceRefsWithRegion()

void CSG::CSGBase::replaceSurfaceRefsWithRegion	(	const CSGSurface &	old_surf,
		const CSGRegion &	sub_region
	)

private

Replace all region occurrences of old_surf with the tokens from sub_region across all cells in the base.

Definition at line 1575 of file CSGBase.C.

{
  for (const auto & cell_ref : getAllCells())
  {
    const CSGCell & cell = cell_ref.get();
    CSGRegion new_region = cell.getRegion();
    if (new_region.getRegionType() == CSGRegion::RegionType::EMPTY)
      continue; // cell units do not have a region so skip (can also skip if a regular cell has an
                // empty region)
    new_region.replaceWithSubRegion(old_surf, sub_region);
    updateCellRegion(cell, new_region);
  }
}

◆ replaceUniverseRefs()

void CSG::CSGBase::replaceUniverseRefs	(	const CSGUniverse &	old_univ,
		const CSGUniverse &	new_univ
	)

private

Replace all cell fills and lattice elements/outers referencing old_univ with new_univ.

Definition at line 1530 of file CSGBase.C.

{
  // 1. Cell fills
  for (const auto & cell_ref : getAllCells())
  {
    const CSGCell & cell = cell_ref.get();
    if (cell.getFillType() == "UNIVERSE" && cell.getFillUniverse() == old_univ)
      updateCellFill(cell, &new_univ);
  }
 
  // 2. Lattice universe maps and outer fills
  for (const auto & lat_ref : getAllLattices())
  {
    const CSGLattice & lat = lat_ref.get();
    if (lat.getOuterType() == "UNIVERSE" && lat.getOuterUniverse() == old_univ)
      setLatticeOuter(lat, new_univ);
 
    auto lat_map = lat.getUniverses();
    for (std::size_t row = 0; row < lat_map.size(); ++row)
      for (std::size_t col = 0; col < lat_map[row].size(); ++col)
        if (lat_map[row][col].get() == old_univ)
          setUniverseAtLatticeIndex(lat, new_univ, {static_cast<int>(row), static_cast<int>(col)});
  }
 
  // 3. Root universe pointer in universe list
  if (getRootUniverse() == old_univ)
    _universe_list._root_universe = &new_univ;
}

◆ replaceUniverseRefsByName()

void CSG::CSGBase::replaceUniverseRefsByName	(	std::map< std::string, std::reference_wrapper< const CSGUniverse > > &	identical_universe_refs,
		CSGBase &	base
	)

private

update universe references of incoming CSGbase to point to those of existing CSGBase object based on CSGUniverse name.

This involves updating the universe references of cells and universe references of lattices.

Parameters

identical_universe_refs	map of universe names to universe references that will be used for replacement
base	CSGBase object that contains references that should be updated

Definition at line 917 of file CSGBase.C.

{
  // Update universe references of cells to those of this base
  for (auto & [cell_name, cell_ptr] : base.getCellList().getCellListMap())
  {
    const auto fill_type = cell_ptr->getFillType();
    const auto fill_name = cell_ptr->getFillName();
    if ((fill_type == "UNIVERSE") &&
        (identical_universe_refs.find(fill_name) != identical_universe_refs.end()))
    {
      const CSGUniverse * univ_ptr = &identical_universe_refs.at(fill_name).get();
      cell_ptr->updateCellFill(univ_ptr);
    }
  }
 
  // Update universe references of lattices to those of this base
  for (auto & [lat_name, lat_ptr] : base.getLatticeList().getLatticeListMap())
    for (auto & [univ_name, univ_ref] : identical_universe_refs)
    {
      // Check if universe belongs to lattice
      if (lat_ptr->hasUniverse(univ_name))
      {
        // If so, replace all instances of this universe in the lattice
        const auto univ_indices = lat_ptr->getUniverseIndices(univ_name);
        for (const auto & index : univ_indices)
          lat_ptr->setUniverseAtIndex(univ_ref, index);
      }
      // Check if universe belongs to lattice outer
      if ((lat_ptr->getOuterType() == "UNIVERSE") &&
          (lat_ptr->getOuterUniverse().getName() == univ_name))
        lat_ptr->updateOuter(univ_ref);
    }
}

◆ resetCellFill()

void CSG::CSGBase::resetCellFill ( const CSGCell & cell )

reset the fill of the specified cell to void

Parameters

cell	cell to update the fill for

Definition at line 393 of file CSGBase.C.

{
  // cannot update region for a cell that is actually an engineering unit
  if (cellToEngUnit(cell))
    mooseError("Fill cannot be reset for cell '" + cell.getName() +
               "' because it is a CSGCellEngUnit.");
 
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.resetCellFill();
}

◆ resetLatticeOuter()

void CSG::CSGBase::resetLatticeOuter ( const CSGLattice & lattice )

reset the outer fill for the lattice to VOID

Parameters

lattice lattice to update

Definition at line 607 of file CSGBase.C.

{
  auto name = lattice.getName();
  if (!checkLatticeInBase(lattice))
    mooseError("Cannot reset outer for lattice " + name +
               ". Lattice is different from the lattice of the same name in the "
               "CSGBase instance.");
  _lattice_list.getLattice(name).resetOuter();
}

◆ setLatticeOuter() [1/2]

void CSG::CSGBase::setLatticeOuter	(	const CSGLattice &	lattice,
		const CSGUniverse &	outer_univ
	)

Set the outer fill for the lattice to the universe provided.

This will set the outer type to UNIVERSE regardless of its previous outer type.

Parameters

lattice	lattice to update
outer_univ	universe to use as outer fill between lattice elements

Definition at line 593 of file CSGBase.C.

{
  auto name = lattice.getName();
  if (!checkLatticeInBase(lattice))
    mooseError("Cannot set outer universe for lattice " + name +
               ". Lattice is different from the lattice of the same name in the "
               "CSGBase instance.");
  if (!checkUniverseInBase(outer_univ))
    mooseError("Cannot set outer universe for lattice " + name + ". Outer universe " +
               outer_univ.getName() + " is not in the CSGBase instance.");
  _lattice_list.getLattice(name).updateOuter(outer_univ);
}

◆ setLatticeOuter() [2/2]

void CSG::CSGBase::setLatticeOuter	(	const CSGLattice &	lattice,
		const std::string &	outer_name
	)

Set the outer fill for the lattice to the material name provided.

This will set the outer type to CSG_MATERIAL regardless of its previous outer type.

Parameters

lattice	lattice to update
outer_name	name of material to use as outer fill between lattice elements

Definition at line 582 of file CSGBase.C.

{
  auto name = lattice.getName();
  if (!checkLatticeInBase(lattice))
    mooseError("Cannot set outer for lattice " + name +
               ". Lattice is different from the lattice of the same name in the "
               "CSGBase instance.");
  _lattice_list.getLattice(name).updateOuter(outer_name);
}

◆ setLatticeUniverses()

void CSG::CSGBase::setLatticeUniverses	(	const CSGLattice &	lattice,
		std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > &	universes
	)

Set provided universes as the layout of the lattice.

Parameters

lattice	lattice to add universes to
universes	list of list of universes in the proper layout for the lattice type and dimensions

Definition at line 634 of file CSGBase.C.

{
  auto name = lattice.getName();
  if (!checkLatticeInBase(lattice))
    mooseError("Cannot set universes for lattice " + name +
               ". Lattice is different from the lattice of the same name in the "
               "CSGBase instance.");
  // make sure all universes are a part of this base instance
  for (auto univ_list : universes)
    for (const CSGUniverse & univ : univ_list)
      if (!checkUniverseInBase(univ))
        mooseError("Cannot set universes for lattice " + name + ". Universe " + univ.getName() +
                   " is not in the CSGBase instance.");
  _lattice_list.getLattice(name).setUniverses(universes);
}

◆ setUniverseAtLatticeIndex()

void CSG::CSGBase::setUniverseAtLatticeIndex	(	const CSGLattice &	lattice,
		const CSGUniverse &	universe,
		std::pair< int, int >	index
	)

set location in the lattice to be the provided universe

Parameters

lattice	lattice to update
universe	universe to set at the location
index	index of the lattice element (int, int)

Definition at line 618 of file CSGBase.C.

{
  auto name = lattice.getName();
  if (!checkLatticeInBase(lattice))
    mooseError("Cannot set universe at index for lattice " + name +
               ". Lattice is different from the lattice of the same name in the "
               "CSGBase instance.");
  if (!checkUniverseInBase(universe))
    mooseError("Cannot add universe " + universe.getName() + " to lattice " + lattice.getName() +
               ". Universe is not in the CSGBase instance.");
  _lattice_list.getLattice(name).setUniverseAtIndex(universe, index);
}

◆ surfaceToEngUnit()

const CSGSurfaceEngUnit * CSG::CSGBase::surfaceToEngUnit ( const CSGSurface & surf ) const

inlineprivate

Returns the CSGSurfaceEngUnit pointer if surf is an eng unit, nullptr otherwise.

Usable as a boolean check or to access the eng unit directly.

Parameters

surf	CSGSurface to check/get as an engineering unit

Returns: const CSGSurfaceEngUnit* or nullptr

Definition at line 1207 of file CSGBase.h.

  {
    return dynamic_cast<const CSGSurfaceEngUnit *>(&surf);
  }

◆ universeToEngUnit()

const CSGUniverseEngUnit * CSG::CSGBase::universeToEngUnit ( const CSGUniverse & univ ) const

inlineprivate

Returns the CSGUniverseEngUnit pointer if univ is an eng unit, nullptr otherwise.

Usable as a boolean check or to access the eng unit directly.

Parameters

univ	CSGUniverse to check/get as an engineering unit

Returns: const CSGUniverseEngUnit* or nullptr

Definition at line 1231 of file CSGBase.h.

  {
    return dynamic_cast<const CSGUniverseEngUnit *>(&univ);
  }

Referenced by CSGBase().

◆ updateCellFill() [1/3]

void CSG::CSGBase::updateCellFill	(	const CSGCell &	cell,
		const CSGLattice *	lattice
	)

change the fill of the specified cell to a lattice fill

Parameters

cell	cell to update the fill for
lattice	pointer to lattice fill

Definition at line 446 of file CSGBase.C.

{
  // cannot update region for a cell that is actually an engineering unit
  if (cellToEngUnit(cell))
    mooseError("Fill cannot be updated for cell '" + cell.getName() +
               "' because it is a CSGCellEngUnit.");
 
  if (!checkLatticeInBase(*lattice))
    mooseError("Lattice with name ",
               lattice->getName(),
               " is being used as a cell fill that is different from the lattice of the same name "
               "in the CSGBase instance.");
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(lattice);
}

◆ updateCellFill() [2/3]

void CSG::CSGBase::updateCellFill	(	const CSGCell &	cell,
		const CSGUniverse *	univ
	)

change the fill of the specified cell to a universe fill

Parameters

cell	cell to update the fill for
univ	pointer to universe fill

Definition at line 425 of file CSGBase.C.

{
  // cannot update region for a cell that is actually an engineering unit
  if (cellToEngUnit(cell))
    mooseError("Fill cannot be updated for cell '" + cell.getName() +
               "' because it is a CSGCellEngUnit.");
 
  if (!checkUniverseInBase(*univ))
    mooseError("Universe with name ",
               univ->getName(),
               " is being used as a cell fill that is different from the universe of the same name "
               "in the CSGBase instance.");
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(univ);
}

◆ updateCellFill() [3/3]

void CSG::CSGBase::updateCellFill	(	const CSGCell &	cell,
		const std::string &	mat_name
	)

change the fill of the specified cell to a material fill

Parameters

cell	cell to update the fill for
mat_name	name of material fill

Definition at line 409 of file CSGBase.C.

{
  // cannot update region for a cell that is actually an engineering unit
  if (cellToEngUnit(cell))
    mooseError("Fill cannot be updated for cell '" + cell.getName() +
               "' because it is a CSGCellEngUnit.");
 
  if (!checkCellInBase(cell))
    mooseError("The region of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(mat_name);
}

◆ updateCellRegion()

void CSG::CSGBase::updateCellRegion	(	const CSGCell &	cell,
		const CSGRegion &	region
	)

change the region of the specified cell

Parameters

cell	cell to update the region for
region	new region to assign to cell

Definition at line 376 of file CSGBase.C.

{
  // cannot update region for a cell that is actually an engineering unit
  if (cellToEngUnit(cell))
    mooseError("Region cannot be updated for cell '" + cell.getName() +
               "' because it is a CSGCellEngUnit.");
 
  checkRegionSurfaces(region);
  if (!checkCellInBase(cell))
    mooseError("The region of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateRegion(region);
}

◆ updateIncomingCSGReferences()

void CSG::CSGBase::updateIncomingCSGReferences ( CSGBase & incoming_base )

private

update references of incoming CSGbase to point to those of existing CSGBase object.

This includes updating the surface references of cell regions, universe/lattice references of cell fills, cell references of universes, and universe references of lattices

Parameters

incoming_base CSGBase object that contains references that should be updated

Definition at line 842 of file CSGBase.C.

{
  // Iterate through all incoming surfaces and track which ones have names already
  // defined within this CSGSurfaceList object
  std::map<std::string, std::reference_wrapper<const CSGSurface>> identical_surface_refs;
  auto & surf_list_map = incoming_base.getSurfaceList().getSurfaceListMap();
  for (const auto & [surf_name, surf_ptr] : surf_list_map)
    if (hasSurface(surf_name))
      identical_surface_refs.insert({surf_name, getSurfaceByName(surf_name)});
 
  // Iterate through all incoming cells and track which ones have names already
  // defined within this CSGCellList object
  std::map<std::string, std::reference_wrapper<const CSGCell>> identical_cell_refs;
  auto & cell_list_map = incoming_base.getCellList().getCellListMap();
  for (const auto & [cell_name, cell_ptr] : cell_list_map)
    if (hasCell(cell_name))
      identical_cell_refs.insert({cell_name, getCellByName(cell_name)});
 
  // Iterate through all incoming universes and track which ones have names already
  // defined within this CSGUniverseList object
  std::map<std::string, std::reference_wrapper<const CSGUniverse>> identical_universe_refs;
  auto & universe_list_map = incoming_base.getUniverseList().getUniverseListMap();
  for (const auto & [univ_name, univ_ptr] : universe_list_map)
    if (hasUniverse(univ_name))
      identical_universe_refs.insert({univ_name, getUniverseByName(univ_name)});
 
  // Iterate through all incoming lattices and track which ones have names already
  // defined within this CSGLatticeList object
  std::map<std::string, std::reference_wrapper<const CSGLattice>> identical_lattice_refs;
  auto & lattice_list_map = incoming_base.getLatticeList().getLatticeListMap();
  for (const auto & [lat_name, lat_ptr] : lattice_list_map)
    if (hasLattice(lat_name))
      identical_lattice_refs.insert({lat_name, getLatticeByName(lat_name)});
 
  // Update all surface, cell, universe, and lattice references of incoming base to those of this
  // base
  if (!identical_surface_refs.empty())
    replaceSurfaceRefsByName(identical_surface_refs, incoming_base);
 
  if (!identical_cell_refs.empty())
    replaceCellRefsByName(identical_cell_refs, incoming_base);
 
  if (!identical_universe_refs.empty())
    replaceUniverseRefsByName(identical_universe_refs, incoming_base);
 
  if (!identical_lattice_refs.empty())
    replaceLatticeRefsByName(identical_lattice_refs, incoming_base);
}

Member Data Documentation

◆ _cell_list

CSGCellList CSG::CSGBase::_cell_list

private

List of cells associated with CSG object.

Definition at line 1264 of file CSGBase.h.

Referenced by addEngUnit(), CSGBase(), getAllCells(), getCellByName(), getCellList(), getCellList(), and hasCell().

◆ _eng_unit_list

CSGEngUnitList CSG::CSGBase::_eng_unit_list

private

Container for all associated engineering units.

Definition at line 1273 of file CSGBase.h.

Referenced by addEngUnit(), getAllCellEngUnits(), getAllEngUnits(), getAllSurfaceEngUnits(), getAllUniverseEngUnits(), getEngUnitByName(), getEngUnitList(), and hasEngUnit().

◆ _lattice_list

CSGLatticeList CSG::CSGBase::_lattice_list

private

List of lattices associated with CSG object.

Definition at line 1270 of file CSGBase.h.

Referenced by addLattice(), getAllLattices(), getLatticeByName(), getLatticeList(), getLatticeList(), hasLattice(), and renameLattice().

◆ _surface_list

CSGSurfaceList CSG::CSGBase::_surface_list

private

List of surfaces associated with CSG object.

Definition at line 1261 of file CSGBase.h.

Referenced by addEngUnit(), getAllSurfaces(), getSurface(), getSurfaceByName(), getSurfaceList(), getSurfaceList(), and hasSurface().

◆ _universe_list

CSGUniverseList CSG::CSGBase::_universe_list

private

List of universes associated with CSG object.

Definition at line 1267 of file CSGBase.h.

Referenced by addEngUnit(), createUniverse(), getAllUniverses(), getRootUniverse(), getUniverseByName(), getUniverseList(), getUniverseList(), hasUniverse(), and renameRootUniverse().

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

include/csg/CSGBase.h
src/csg/CSGBase.C

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CSGBase() [1/2]

◆ CSGBase() [2/2]

◆ ~CSGBase()

Member Function Documentation

◆ addCellsToUniverse()

◆ addCellToList()

◆ addCellToUniverse()

◆ addEngUnit()

◆ addLattice()

◆ addLatticeToList()

◆ addSurface()

◆ addTransformation() [1/2]

◆ addTransformation() [2/2]

◆ addUniverseToList()

◆ applyAxisRotation() [1/2]

◆ applyAxisRotation() [2/2]

◆ applyRotation() [1/2]

◆ applyRotation() [2/2]

◆ applyScaling() [1/2]

◆ applyScaling() [2/2]

◆ applyTranslation() [1/2]

◆ applyTranslation() [2/2]

◆ areCSGObjectsLinked()

◆ cellToEngUnit()

◆ checkCellInBase()

◆ checkEngUnitInBase()

◆ checkLatticeInBase()

◆ checkRegionSurfaces()

◆ checkSurfaceInBase()

◆ checkUniverseInBase()

◆ checkUniverseLinking()

◆ clone()

◆ createCell() [1/4]

◆ createCell() [2/4]

◆ createCell() [3/4]

◆ createCell() [4/4]

◆ createUniverse() [1/2]

◆ createUniverse() [2/2]

◆ deleteCell()

◆ deleteEngUnit()

◆ deleteLattice()

◆ deleteSurface()

◆ deleteUniverse()

◆ expandAllEngUnits()

◆ expandAllEngUnitsCycle()

◆ expandEngUnit() [1/3]

◆ expandEngUnit() [2/3]

◆ expandEngUnit() [3/3]

◆ FRIEND_TEST() [1/6]

◆ FRIEND_TEST() [2/6]

◆ FRIEND_TEST() [3/6]

◆ FRIEND_TEST() [4/6]

◆ FRIEND_TEST() [5/6]

◆ FRIEND_TEST() [6/6]

◆ generateOutput()

◆ getAllCellEngUnits()

◆ getAllCells()

◆ getAllEngUnits()

◆ getAllLattices()

◆ getAllSurfaceEngUnits()

◆ getAllSurfaces()

◆ getAllUniverseEngUnits()

◆ getAllUniverses()

◆ getCellByName()

◆ getCellList() [1/2]

◆ getCellList() [2/2]

◆ getEngUnitByName()

◆ getEngUnitList()

◆ getLatticeByName()

◆ getLatticeList() [1/2]

◆ getLatticeList() [2/2]

◆ getLinkedCSGObjects()

◆ getRootUniverse()

◆ getSurface()

◆ getSurfaceByName()