https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
CSG::CSGBase Class Reference

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 checkGeometry () const
 Check that the geometry is valid for output and conversion to downstream codes.
 
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 checkCellUniverseMembership () const
 Check that each cell belongs to at most one universe.
 
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, testCellUniverseMembership)
 
 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 18 of file CSGBase.C.

19 : _surface_list(CSGSurfaceList()),
20 _cell_list(CSGCellList()),
21 _universe_list(CSGUniverseList()),
22 _lattice_list(CSGLatticeList())
23{
24}
CSGCellList _cell_list
List of cells associated with CSG object.
Definition CSGBase.h:1276
CSGSurfaceList _surface_list
List of surfaces associated with CSG object.
Definition CSGBase.h:1273
CSGLatticeList _lattice_list
List of lattices associated with CSG object.
Definition CSGBase.h:1282
CSGUniverseList _universe_list
List of universes associated with CSG object.
Definition CSGBase.h:1279

◆ CSGBase() [2/2]

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

Copy constructor.

Definition at line 26 of file CSGBase.C.

27 : _surface_list(other_base.getSurfaceList()),
28 _cell_list(CSGCellList()),
29 _universe_list(CSGUniverseList()),
30 _lattice_list(CSGLatticeList())
31{
32 // Add all engineering units first so the recursive addCellToList / addUniverseToList calls
33 // below can find them via hasCell() / hasUniverse() and return early without erroring.
34 // Cell engineering units do not have universes and universe engineering units do not contain
35 // cells in the same way that the plain objects do, so we do not need to worry about recursion.
36
37 // Bypass addCellToList because it doesn't properly handle engineering units and also bypass
38 // addEngUnit for cells to avoid erroneously adding it to the root universe if it is not
39 // necessary.
40 for (const auto & eng_unit : other_base.getAllCellEngUnits())
41 _cell_list.addCell(eng_unit.get().clone());
42
43 for (const auto & eng_unit : other_base.getAllUniverseEngUnits())
44 addEngUnit(eng_unit.get().clone());
45
46 // Iterate through all non-eng unit cell references from the other CSGBase instance and
47 // create new CSGCell pointers based on these references. This is done
48 // recursively to properly handle cells with universe fills.
49 for (const auto & [name, cell] : other_base.getCellList().getCellListMap())
50 if (!cellToEngUnit(*cell))
51 addCellToList(*cell);
52
53 // Link all cells in other_base root universe to current root universe
54 for (auto & root_cell : other_base.getRootUniverse().getAllCells())
55 {
56 const auto & list_cell = _cell_list.getCell(root_cell.get().getName());
58 }
59
60 // Iterate through all non-eng unit universe references from the other CSGBase instance and
61 // create new CSGUniverse pointers based on these references. This is done in case
62 // any universe exist in the universe list that are not connected to the cell list.
63 for (const auto & [name, univ] : other_base.getUniverseList().getUniverseListMap())
64 if (!universeToEngUnit(*univ))
65 addUniverseToList(*univ);
66
67 // Iterate through all lattice references from the other CSGBase instance and
68 // create new CSGLattice pointers based on these references.
69 for (const auto & [name, lattice] : other_base.getLatticeList().getLatticeListMap())
70 addLatticeToList(*lattice);
71
72 // Rebuild the eng unit index from the now-complete surface, cell, and universe lists.
74}
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
const CSGCell & addCellToList(const CSGCell &cell)
Add a new cell to the cell list based on a cell reference.
Definition CSGBase.C:137
const CSGCellList & getCellList() const
Get a const reference to the CSGCellList object.
Definition CSGBase.h:998
std::unique_ptr< CSGBase > clone() const
Create a deep copy of this CSGBase instance.
Definition CSGBase.C:79
const CSGLattice & addLatticeToList(const CSGLattice &lattice)
Add a new lattice to the lattice list based on a lattice reference.
Definition CSGBase.C:203
const CSGUniverse & addUniverseToList(const CSGUniverse &univ)
Add a new universe to the universe list based on a universe reference.
Definition CSGBase.C:178
std::vector< std::reference_wrapper< const CSGUniverseEngUnit > > getAllUniverseEngUnits() const
Get all universe-like engineering units.
Definition CSGBase.h:659
std::vector< std::reference_wrapper< const CSGCell > > getAllCells() const
Get all cell objects.
Definition CSGBase.h:204
const CSGUniverseList & getUniverseList() const
Get a const reference to the CSGUniverseList object.
Definition CSGBase.h:1012
void rebuildEngUnitList()
rebuilds the list of raw pointers to engineering units by iterating through the surface,...
Definition CSGBase.C:998
const CSGLatticeList & getLatticeList() const
Get a const reference to the CSGLatticeList object.
Definition CSGBase.h:1026
const CSGUniverse & getRootUniverse() const
Get the Root Universe object.
Definition CSGBase.h:277
const CSGUniverseEngUnit * universeToEngUnit(const CSGUniverse &univ) const
Returns the CSGUniverseEngUnit pointer if univ is an eng unit, nullptr otherwise.
Definition CSGBase.h:1243
std::vector< std::reference_wrapper< const CSGCellEngUnit > > getAllCellEngUnits() const
Get all cell-like engineering units in CSGBase.
Definition CSGBase.h:649
void addCellToUniverse(const CSGUniverse &universe, const CSGCell &cell)
Add a cell to an existing universe.
Definition CSGBase.C:526
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.
Definition CSGBase.h:539
const CSGCellEngUnit * cellToEngUnit(const CSGCell &cell) const
Returns the CSGCellEngUnit pointer if cell is an eng unit, nullptr otherwise.
Definition CSGBase.h:1231
CSGCell & getCell(const std::string &name) const
Get the CSGCell by name.
Definition CSGCellList.C:44
const Elem & get(const ElemType type_in)

◆ ~CSGBase()

CSG::CSGBase::~CSGBase ( )

Destructor.

Definition at line 76 of file CSGBase.C.

76{}

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
universeuniverse to which to add the cells
cellslist of references to cells to add

Definition at line 548 of file CSGBase.C.

550{
551 for (auto & c : cells)
552 addCellToUniverse(universe, c);
553}

◆ 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
cellreference to CSGCell that should be added to cell list

Definition at line 137 of file CSGBase.C.

138{
139 // If cell has already been created, we just return a reference to it
140 const auto name = cell.getName();
141 if (_cell_list.hasCell(name))
142 return _cell_list.getCell(name);
143
144 // Engineering unit cells must be registered via addEngUnit(), not addCellToList()
145 if (cellToEngUnit(cell))
146 mooseError("Cell '",
147 name,
148 "' is a CSGCellEngUnit and must be added via addEngUnit(), not addCellToList().");
149
150 // Otherwise if the cell has material or void cell, we can create it directly
151 const auto fill_type = cell.getFillType();
152 const auto region = cell.getRegion();
153 if (fill_type == "VOID")
154 return _cell_list.addVoidCell(name, region);
155 else if (fill_type == "CSG_MATERIAL")
156 {
157 const auto mat_name = cell.getFillMaterial();
158 return _cell_list.addMaterialCell(name, mat_name, region);
159 }
160 else if (fill_type == "LATTICE")
161 {
162 // add lattice recursively to capture all linked universes in the lattice
163 const CSGLattice & lattice = addLatticeToList(cell.getFillLattice());
164 return _cell_list.addLatticeCell(name, lattice, region);
165 }
166 // Otherwise if the cell has a universe fill, we need to recursively define
167 // all linked universes and cells first before defining this cell
168 else if (fill_type == "UNIVERSE")
169 {
170 const auto & univ = addUniverseToList(cell.getFillUniverse());
171 return _cell_list.addUniverseCell(name, univ, region);
172 }
173 else
174 mooseError("Cell " + name + " has unrecognized fill type " + fill_type);
175}
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311
CSGCell & addLatticeCell(const std::string &name, const CSGLattice &lattice, const CSGRegion &region)
Add a Lattice Cell object to cell list.
Definition CSGCellList.C:75
bool hasCell(const std::string &name) const
return whether cell with given name exists in cell list
Definition CSGCellList.h:85
CSGCell & addVoidCell(const std::string &name, const CSGRegion &region)
Add a Void Cell object cell list.
Definition CSGCellList.C:53
CSGCell & addMaterialCell(const std::string &name, const std::string &mat_name, const CSGRegion &region)
Add a Material Cell object to cell list.
Definition CSGCellList.C:59
CSGCell & addUniverseCell(const std::string &name, const CSGUniverse &univ, const CSGRegion &region)
Add a Universe Cell object to cell list.
Definition CSGCellList.C:67
const std::string & getFillMaterial() const
Get the cell fill material name if fill fype is CSG_MATERIAL.
Definition CSGCell.C:68
std::string name(const ElemQuality q)

Referenced by CSGBase().

◆ addCellToUniverse()

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

Add a cell to an existing universe.

Parameters
universeuniverse to which to add the cell
cellcell to add

Definition at line 526 of file CSGBase.C.

527{
528 // if universe is actually engineering unit, cannot add cells
529 if (universeToEngUnit(universe))
530 mooseError("Universe '" + universe.getName() +
531 "' cannot add cells because it is a CSGUniverseEngUnit.");
532
533 // make sure cell is a part of this CSGBase instance
534 if (!checkCellInBase(cell))
535 mooseError("A cell named " + cell.getName() + " is being added to universe " +
536 universe.getName() +
537 " that is different from the cell of the same name in the CSGBase instance.");
538 // make sure universe is a part of this CSGBase instance
539 if (!checkUniverseInBase(universe))
540 mooseError("Cells are being added to a universe named " + universe.getName() +
541 " that is different " +
542 "from the universe of the same name in the CSGBase instance.");
543 auto & univ = _universe_list.getUniverse(universe.getName());
544 univ.addCell(cell);
545}
bool checkCellInBase(const CSGCell &cell) const
check that cell being accessed is a part of this CSGBase instance
Definition CSGBase.C:1109
bool checkUniverseInBase(const CSGUniverse &universe) const
check that universe being accessed is a part of this CSGBase instance
Definition CSGBase.C:1119
CSGUniverse & getUniverse(const std::string &name) const
Get a Universe from the list by its name.
void addCell(const CSGCell &cell)
add cell to universe
Definition CSGUniverse.C:29

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
Ta type derived from CSGSurfaceEngUnit, CSGCellEngUnit, or CSGUniverseEngUnit
Parameters
unitunique_ptr to the engineering unit to register
add_to_univoptional 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.

540 {
541 static_assert(std::is_base_of_v<CSGEngUnit, T>, "T must derive from CSGEngUnit");
542 static_assert(std::is_base_of_v<CSGSurface, T> || std::is_base_of_v<CSGCell, T> ||
543 std::is_base_of_v<CSGUniverse, T>,
544 "T must also derive from CSGSurface, CSGCell, or CSGUniverse");
545 // create raw pointer so we can transfer ownership to the proper type list without destroying
546 // it, and also can store the pointer in the CSGEngUnitList (non-owning list)
547 T * raw = unit.get();
548
549 // must check if an engineering unit of the same name (regardless of type) exists already before
550 // adding it to any list so that we don't add to a type-list before knowing if it is actually
551 // allowable as a unit. The addX checks below will check that the name doesn't conflict with a
552 // real type unit too.
553 if (_eng_unit_list.hasEngUnit(raw->getName()))
555 "An engineering unit with name '", raw->getName(), "' already exists in geometry.");
556
557 // Transfer ownership to the appropriate type list
558 if constexpr (std::is_base_of_v<CSGSurface, T>)
559 _surface_list.addSurface(std::move(unit));
560 else if constexpr (std::is_base_of_v<CSGCell, T>)
561 {
562 // must add a cell unit to the appropriate universe
563 auto & cell = _cell_list.addCell(std::move(unit));
564 if (add_to_univ)
565 addCellToUniverse(*add_to_univ, cell);
566 else
568 }
569 else if constexpr (std::is_base_of_v<CSGUniverse, T>)
570 _universe_list.addUniverse(std::move(unit));
571
572 // Register non-owning pointer in the CSGEngUnitList if no name conflicts identified above.
573 _eng_unit_list.addEngUnit(cast_ref<CSGEngUnit &>(*raw));
574 return *raw;
575 }
CSGEngUnitList _eng_unit_list
Container for all associated engineering units.
Definition CSGBase.h:1285
CSGCell & addCell(std::unique_ptr< CSGCell > cell, const bool ignore_identical_cell=false)
add a cell to the CellList.
Definition CSGCellList.C:18
CSGEngUnit & addEngUnit(CSGEngUnit &unit)
Register an engineering unit in this index.
bool hasEngUnit(const std::string &name) const
Return whether an engineering unit with the given name exists in this list.
CSGSurface & addSurface(std::unique_ptr< CSGSurface > surf, const bool ignore_identical_surface=false)
add a surface object to existing SurfaceList.
CSGUniverse & addUniverse(const std::string &name)
create an empty universe

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
latticepointer to lattice to add
Returns
reference to CSGLattice that was added

Definition at line 398 of file CSGBase.h.

399 {
400 static_assert(std::is_base_of_v<CSGLattice, LatticeType>, "Is not a CSGLattice");
401 // make sure all universes are a part of this base instance
402 auto universes = lattice->getUniverses();
403 for (auto univ_list : universes)
404 for (const CSGUniverse & univ : univ_list)
405 if (!checkUniverseInBase(univ))
406 mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
407 ". Universe " + univ.getName() + " is not in the CSGBase instance.");
408
409 if (lattice->getOuterType() == "UNIVERSE")
410 {
411 const CSGUniverse & outer_univ = lattice->getOuterUniverse();
412 if (!checkUniverseInBase(outer_univ))
413 mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
414 ". Outer universe " + outer_univ.getName() + " is not in the CSGBase instance.");
415 }
416 auto & lat_ref = _lattice_list.addLattice(std::move(lattice));
417 return dynamic_cast<LatticeType &>(lat_ref);
418 }
for(PetscInt i=0;i< nvars;++i)
CSGLattice & addLattice(std::unique_ptr< CSGLattice > lattice, const bool ignore_identical_lattice=false)
add an existing lattice to list.

◆ 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
latticereference to CSGLattice that should be added to universe list

Definition at line 203 of file CSGBase.C.

204{
205 // If lattice has already been created, we just return a reference to it
206 const auto name = lattice.getName();
207 if (_lattice_list.hasLattice(name))
208 return _lattice_list.getLattice(name);
209
210 // Clone the lattice (associated universes need to be transferred and set)
211 auto cloned_lattice = lattice.clone();
212
213 // If lattice has associated universes, we need to add them to this CSGBase instance as well.
214 // addUniverseToList is called recursively in case associated universes have not been added to
215 // the universe list yet.
216 std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> current_univ_map;
217 for (const auto & univ_list : lattice.getUniverses())
218 {
219 std::vector<std::reference_wrapper<const CSGUniverse>> current_univ_list;
220 for (const auto & univ_ref : univ_list)
221 current_univ_list.push_back(addUniverseToList(univ_ref.get()));
222 current_univ_map.push_back(current_univ_list);
223 }
224
225 // Set universes only if lattice has universes defined
226 if (current_univ_map.size() > 0)
227 cloned_lattice->setUniverses(current_univ_map);
228
229 // Update reference to outer universe if it exists
230 if (lattice.getOuterType() == "UNIVERSE")
231 {
232 const auto & outer_univ_ref = addUniverseToList(lattice.getOuterUniverse());
233 cloned_lattice->updateOuter(outer_univ_ref);
234 }
235
236 // Use addLattice to add the cloned lattice
237 return addLattice(std::move(cloned_lattice));
238}
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...
Definition CSGBase.h:398
CSGLattice & getLattice(const std::string &name) const
Get a Lattice from the list by its name.
bool hasLattice(const std::string &name) const
return whether lattice with given name exists in lattice list
virtual std::unique_ptr< CSGLattice > clone() const =0

Referenced by CSGBase().

◆ addSurface()

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

add a unique surface pointer to this base instance

Parameters
surfpointer to surface to add
Returns
reference to CSGSurface that was added

Definition at line 97 of file CSGBase.C.

98{
99 if (surfaceToEngUnit(*surf))
100 mooseError("Surface '",
101 surf->getName(),
102 "' is a CSGSurfaceEngUnit and must be added via addEngUnit(), not addSurface().");
103 return _surface_list.addSurface(std::move(surf));
104}
const CSGSurfaceEngUnit * surfaceToEngUnit(const CSGSurface &surf) const
Returns the CSGSurfaceEngUnit pointer if surf is an eng unit, nullptr otherwise.
Definition CSGBase.h:1219

◆ 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
unitThe CSGEngUnit object to transform (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
typeThe type of transformation to apply (TRANSLATION, ROTATION, SCALE)
valuestuple 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 816 of file CSGBase.h.

819 {
820 addTransformation(CSGObjectVariant{std::cref(unit)}, type, values);
821 }
std::array< Real, 2 > values
Definition MortarUtils.C:52
void addTransformation(const CSGObjectVariant &csg_object, TransformationType type, const std::tuple< Real, Real, Real > &values)
Apply a transformation to a CSG object.
Definition CSGBase.C:654
std::variant< std::reference_wrapper< const CSGSurface >, std::reference_wrapper< const CSGCell >, std::reference_wrapper< const CSGUniverse >, std::reference_wrapper< const CSGRegion >, std::reference_wrapper< const CSGLattice >, std::reference_wrapper< const CSGEngUnit > > CSGObjectVariant
Define a variant type that can hold references to different CSG object types.
Definition CSGBase.h:47

◆ 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_objectThe CSG object to transform (Surface, Cell, Universe, Region, or Lattice)
typeThe type of transformation to apply (TRANSLATION, ROTATION, SCALE)
valuestuple of transformation values (3 values for any transformation type)

Definition at line 654 of file CSGBase.C.

657{
658 // Use std::visit to handle each type in the variant
659 std::visit(
660 [&](const auto & obj)
661 {
662 using T = std::decay_t<decltype(obj.get())>;
663
664 // Handle each CSG object type differently because each needs to check that it exists in
665 // this base instance
666 if constexpr (std::is_same_v<T, CSGCell>)
667 {
668 const CSGCell & cell = obj.get();
669 if (!checkCellInBase(cell))
670 mooseError("Cannot apply transformation to cell ",
671 cell.getName(),
672 " that is not in this CSGBase instance.");
673
674 // Get non-const reference and apply transformation
675 CSGCell & mutable_cell = _cell_list.getCell(cell.getName());
676 mooseAssert(mutable_cell == cell, "Mutable cell does not match const cell passed in.");
677 mutable_cell.addTransformation(type, values);
678 }
679 else if constexpr (std::is_same_v<T, CSGSurface>)
680 {
681 const CSGSurface & surface = obj.get();
682 if (!checkSurfaceInBase(surface))
683 mooseError("Cannot apply transformation to surface ",
684 surface.getName(),
685 " that is not in this CSGBase instance.");
686
687 // Get non-const reference and apply transformation
688 CSGSurface & mutable_surface = _surface_list.getSurface(surface.getName());
689 mooseAssert(mutable_surface == surface,
690 "Mutable surface does not match const surface passed in.");
691 mutable_surface.addTransformation(type, values);
692 }
693 else if constexpr (std::is_same_v<T, CSGUniverse>)
694 {
695 const CSGUniverse & universe = obj.get();
696 if (!checkUniverseInBase(universe))
697 mooseError("Cannot apply transformation to universe ",
698 universe.getName(),
699 " that is not in this CSGBase instance.");
700
701 // Get non-const reference and apply transformation
702 CSGUniverse & mutable_universe = _universe_list.getUniverse(universe.getName());
703 mooseAssert(mutable_universe == universe,
704 "Mutable universe does not match const universe passed in.");
705 mutable_universe.addTransformation(type, values);
706 }
707 else if constexpr (std::is_same_v<T, CSGLattice>)
708 {
709 const CSGLattice & lattice = obj.get();
710 if (!checkLatticeInBase(lattice))
711 mooseError("Cannot apply transformation to lattice ",
712 lattice.getName(),
713 " that is not in this CSGBase instance.");
714
715 // Get non-const reference and apply transformation
716 CSGLattice & mutable_lattice = _lattice_list.getLattice(lattice.getName());
717 mooseAssert(mutable_lattice == lattice,
718 "Mutable lattice does not match const lattice passed in.");
719 mutable_lattice.addTransformation(type, values);
720 }
721 else if constexpr (std::is_same_v<T, CSGRegion>)
722 {
723 // iterate on the surfaces of the region and apply the transformation to those surfaces
724 const CSGRegion & region = obj.get();
725 const auto surfaces = region.getSurfaces();
726 for (const CSGSurface & surface : surfaces)
727 {
728 if (!checkSurfaceInBase(surface))
729 mooseError("Cannot apply transformation to region with surface ",
730 surface.getName(),
731 " that is not in this CSGBase instance.");
732 addTransformation(surface, type, values);
733 }
734 }
735 else if constexpr (std::is_same_v<T, CSGEngUnit>)
736 {
737 const CSGEngUnit & eng_unit = obj.get();
738 if (!checkEngUnitInBase(eng_unit))
739 mooseError("Cannot apply transformation to engineering unit ",
740 eng_unit.getName(),
741 " that is not in this CSGBase instance.");
742
743 CSGEngUnit & mutable_eng = _eng_unit_list.getEngUnit(eng_unit.getName());
744 if (auto * s = dynamic_cast<CSGSurfaceEngUnit *>(&mutable_eng))
745 s->addTransformation(type, values);
746 else if (auto * c = dynamic_cast<CSGCellEngUnit *>(&mutable_eng))
747 c->addTransformation(type, values);
748 else if (auto * u = dynamic_cast<CSGUniverseEngUnit *>(&mutable_eng))
749 u->addTransformation(type, values);
750 else
751 mooseError("Engineering unit '",
752 eng_unit.getName(),
753 "' has an unrecognized type for transformation.");
754 }
755 else
756 mooseError("Transformation not implemented for this object type: ", typeid(T).name());
757 },
758 csg_object);
759}
bool checkSurfaceInBase(const CSGSurface &surface) const
check that surface being accessed is a part of this CSGBase instance
Definition CSGBase.C:1099
bool checkEngUnitInBase(const CSGEngUnit &unit) const
check that engineering unit being accessed is a part of this CSGBase instance
Definition CSGBase.C:1139
bool checkLatticeInBase(const CSGLattice &lattice) const
check that lattice being accessed is a part of this CSGBase instance
Definition CSGBase.C:1129
CSGEngUnit & getEngUnit(const std::string &name) const
Get an engineering unit by name.
CSGSurface & getSurface(const std::string &name) const
Get a surface by name.

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
univreference to CSGUniverse that should be added to universe list

Definition at line 178 of file CSGBase.C.

179{
180 // If universe has already been created, we just return a reference to it
181 const auto name = univ.getName();
182 if (_universe_list.hasUniverse(name))
183 return _universe_list.getUniverse(name);
184
185 // Engineering unit universes must be registered via addEngUnit(), not addUniverseToList()
186 if (universeToEngUnit(univ))
187 mooseError("Universe '",
188 name,
189 "' is a CSGUniverseEngUnit and must be added via addEngUnit(), not "
190 "addUniverseToList().");
191
192 // Otherwise we create a new universe based on its associated cells.
193 // addCellToList is called recursively in case associated cells have not
194 // been added to the cell list yet.
195 const auto univ_cells = univ.getAllCells();
196 std::vector<std::reference_wrapper<const CSGCell>> current_univ_cells;
197 for (const auto & univ_cell : univ_cells)
198 current_univ_cells.push_back(addCellToList(univ_cell));
199 return createUniverse(name, current_univ_cells);
200}
const CSGUniverse & createUniverse(const std::string &name)
Create an empty Universe object.
Definition CSGBase.h:303
bool hasUniverse(const std::string &name) const
return whether universe with given name exists in universe list

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
unitThe CSGEngUnit object to rotate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
axisAxis type (X, Y, or Z) about which to rotate
angleangle 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 902 of file CSGBase.h.

903 {
904 applyAxisRotation(CSGObjectVariant{std::cref(unit)}, axis, angle);
905 }
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).
Definition CSGBase.C:762

◆ 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_objectThe CSG object to rotate (Surface, Cell, Universe, Region, or Lattice)
axisAxis type (X, Y, or Z) about which to rotate
angleangle in degrees to rotate about the specified axis

Definition at line 762 of file CSGBase.C.

765{
766 // convert to the Euler angles (phi, theta, psi) based on axis
767 Real phi = 0.0;
768 Real theta = 0.0;
769 Real psi = 0.0;
770
771 switch (axis)
772 {
774 theta = angle;
775 break;
777 phi = 90.0;
778 theta = angle;
779 psi = -90.0;
780 break;
782 phi = angle;
783 break;
784 default:
785 mooseError("Invalid axis type provided for axis rotation.");
786 }
787
788 addTransformation(csg_object, TransformationType::ROTATION, std::make_tuple(phi, theta, psi));
789}
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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
unitThe CSGEngUnit object to rotate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
anglessize 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 875 of file CSGBase.h.

876 {
878 }

◆ 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_objectThe CSG object to rotate (Surface, Cell, Universe, Region, or Lattice)
anglessize 3 tuple {phi, theta, psi} with rotation angles in degrees

Definition at line 858 of file CSGBase.h.

860 {
862 }

◆ 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
unitThe CSGEngUnit object to scale (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
valuessize 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 930 of file CSGBase.h.

◆ 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_objectThe CSG object to scale (Surface, Cell, Universe, Region, or Lattice)
valuessize 3 tuple with scaling values in x, y, and z directions {x, y, z}

Definition at line 913 of file CSGBase.h.

915 {
917 }

◆ 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
unitThe CSGEngUnit object to translate (CSGEngUnit, CSGSurfaceEngUnit, CSGCellEngUnit, CSGUniverseEngUnit, or any derived type)
distancessize 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 847 of file CSGBase.h.

◆ 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_objectThe CSG object to translate (Surface, Cell, Universe, Region, or Lattice)
distancessize 3 tuple with translation distances in x, y, and z directions {x, y, z}

Definition at line 829 of file CSGBase.h.

831 {
833 }

◆ 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 1265 of file CSGBase.C.

1266{
1267 std::set<std::string> linked_univs, linked_cells, linked_surfs;
1268 getLinkedCSGObjects(getRootUniverse(), linked_univs, linked_cells, linked_surfs);
1269
1270 for (const CSGUniverse & univ : getAllUniverses())
1271 if (linked_univs.find(univ.getName()) == linked_univs.end())
1272 return false;
1273
1274 for (const CSGCell & cell : getAllCells())
1275 if (linked_cells.find(cell.getName()) == linked_cells.end())
1276 return false;
1277
1278 for (const CSGSurface & surf : getAllSurfaces())
1279 if (linked_surfs.find(surf.getName()) == linked_surfs.end())
1280 return false;
1281
1282 return true;
1283}
std::vector< std::reference_wrapper< const CSGUniverse > > getAllUniverses() const
Get all universe objects.
Definition CSGBase.h:365
std::vector< std::reference_wrapper< const CSGSurface > > getAllSurfaces() const
Get all surface objects.
Definition CSGBase.h:101
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.
Definition CSGBase.C:1286
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition KokkosUtils.h:40

◆ 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
cellCSGCell to check/get as an engineering unit
Returns
const CSGCellEngUnit* or nullptr

Definition at line 1231 of file CSGBase.h.

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

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 1109 of file CSGBase.C.

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

◆ checkCellUniverseMembership()

void CSG::CSGBase::checkCellUniverseMembership ( ) const
private

Check that each cell belongs to at most one universe.

Definition at line 1237 of file CSGBase.C.

1238{
1239 // Ordered containers so the reported cell and universe names do not depend on the
1240 // unordered universe list iteration order
1241 std::map<std::string, std::set<std::string>> cell_to_universe_names;
1242 for (const CSGUniverse & univ : getAllUniverses())
1243 for (const CSGCell & cell : univ.getAllCells())
1244 cell_to_universe_names[cell.getName()].insert(univ.getName());
1245
1246 for (const auto & [cell_name, univ_names] : cell_to_universe_names)
1247 if (univ_names.size() > 1)
1248 mooseError("Cell with name ",
1249 cell_name,
1250 " belongs to more than one universe (",
1251 MooseUtils::join(univ_names, ", "),
1252 "). Each cell must belong to exactly one universe.");
1253}

◆ 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 1139 of file CSGBase.C.

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

◆ checkGeometry()

void CSG::CSGBase::checkGeometry ( ) const

Check that the geometry is valid for output and conversion to downstream codes.

Warns about universes, cells, and surfaces that are not linked to the root universe, and errors if a cell belongs to more than one universe. Called by generateOutput(); codes that use the CSGBase directly, without writing output, can call it to apply the same checks.

Definition at line 1256 of file CSGBase.C.

1257{
1258 // Check that orphaned universes do not exist in universe list of CSGBase object
1260 // Check that no cell is shared between universes, which downstream codes cannot represent
1262}
void checkCellUniverseMembership() const
Check that each cell belongs to at most one universe.
Definition CSGBase.C:1237
void checkUniverseLinking() const
Check universes linked to root universe match universes defined in _universe_list.
Definition CSGBase.C:1207

◆ 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 1129 of file CSGBase.C.

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

◆ 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 1087 of file CSGBase.C.

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

◆ 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 1099 of file CSGBase.C.

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

◆ 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 1119 of file CSGBase.C.

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

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 1207 of file CSGBase.C.

1208{
1209 std::set<std::string> linked_universe_names;
1210 std::set<std::string> linked_cell_names;
1211 std::set<std::string> linked_surf_names;
1212
1213 // Recursively figure out which CSG objects are linked to root universe
1215 getRootUniverse(), linked_universe_names, linked_cell_names, linked_surf_names);
1216
1217 // Iterate through all universes in universe list and check that they exist in universes linked
1218 // to root universe list. Universe list includes CSGUniverseEngUnits.
1219 for (const CSGUniverse & univ : getAllUniverses())
1220 if (linked_universe_names.find(univ.getName()) == linked_universe_names.end())
1221 mooseWarning("Universe with name ", univ.getName(), " is not linked to root universe.");
1222
1223 // Iterate through all cells in cell list and check that they exist in cells linked
1224 // to root universe
1225 for (const CSGCell & cell : getAllCells())
1226 if (linked_cell_names.find(cell.getName()) == linked_cell_names.end())
1227 mooseWarning("Cell with name ", cell.getName(), " is not linked to root universe.");
1228
1229 // Iterate through all surfaces in surface list and check that they exist in surfaces linked
1230 // to root universe
1231 for (const CSGSurface & surf : getAllSurfaces())
1232 if (linked_surf_names.find(surf.getName()) == linked_surf_names.end())
1233 mooseWarning("Surface with name ", surf.getName(), " is not linked to root universe.");
1234}
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition MooseError.h:345

◆ 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 79 of file CSGBase.C.

80{
81 std::unique_ptr<CSGBase> clone = std::make_unique<CSGBase>(*this);
82
83 // Store list of surface names to surface references in clone to update region definitions
84 std::map<std::string, std::reference_wrapper<const CSGSurface>> identical_surface_refs;
85 auto & surf_list_map = clone->getSurfaceList().getSurfaceListMap();
86 for (const auto & [surf_name, surf_ptr] : surf_list_map)
87 identical_surface_refs.insert({surf_name, clone->getSurfaceByName(surf_name)});
88
89 // Update surface references of cell regions to those of clone
90 for (auto & [cell_name, cell_ptr] : clone->getCellList().getCellListMap())
91 cell_ptr->updateCellRegionSurfaces(identical_surface_refs);
92
93 return clone;
94}

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
nameunique cell name
fill_latticelattice that will fill the cell
regioncell 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 312 of file CSGBase.C.

316{
317 checkRegionSurfaces(region);
318
319 // check that cell is not being added to a universe that exists in the lattice itself
320 if (add_to_univ)
321 for (auto univ_list : fill_lattice.getUniverses())
322 for (const auto & univ_ref : univ_list)
323 {
324 const CSGUniverse & univ_in_lattice = univ_ref.get();
325 if (&univ_in_lattice == add_to_univ)
326 mooseError("Cell " + name +
327 " cannot be filled with a lattice containing the same universe to which it is "
328 "being added.");
329 }
330
331 auto & cell = _cell_list.addLatticeCell(name, fill_lattice, region);
332 if (add_to_univ)
333 addCellToUniverse(*add_to_univ, cell);
334 else
336 return cell;
337}
void checkRegionSurfaces(const CSGRegion &region) const
check that surfaces used in this region are a part of this CSGBase instance
Definition CSGBase.C:1087

◆ 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
nameunique cell name
regioncell 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 279 of file CSGBase.C.

282{
283 checkRegionSurfaces(region);
284 auto & cell = _cell_list.addVoidCell(name, region);
285 if (add_to_univ)
286 addCellToUniverse(*add_to_univ, cell);
287 else
289 return cell;
290}

◆ 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
nameunique cell name
fill_univuniverse that will fill the cell
regioncell 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 293 of file CSGBase.C.

297{
298 checkRegionSurfaces(region);
299 if (add_to_univ && (&fill_univ == add_to_univ))
300 mooseError("Cell " + name +
301 " cannot be filled with the same universe to which it is being added.");
302
303 auto & cell = _cell_list.addUniverseCell(name, fill_univ, region);
304 if (add_to_univ)
305 addCellToUniverse(*add_to_univ, cell);
306 else
308 return cell;
309}

◆ 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
nameunique cell name
mat_namematerial name
regioncell 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 264 of file CSGBase.C.

268{
269 checkRegionSurfaces(region);
270 auto & cell = _cell_list.addMaterialCell(name, mat_name, region);
271 if (add_to_univ)
272 addCellToUniverse(*add_to_univ, cell);
273 else
275 return cell;
276}

◆ createUniverse() [1/2]

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

Create an empty Universe object.

Parameters
nameunique universe name
Returns
reference to CSGUniverse that is created

Definition at line 303 of file CSGBase.h.

304 {
305 return _universe_list.addUniverse(name);
306 }

◆ 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
nameunique universe name
cellslist of cells to add to universe
Returns
reference to CSGUniverse that is created

Definition at line 468 of file CSGBase.C.

470{
471 auto & univ = _universe_list.addUniverse(name);
472 addCellsToUniverse(univ, cells); // performs a check that cells are a part of this base
473 return univ;
474}
void addCellsToUniverse(const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell > > &cells)
Add a list of cells to an existing universe.
Definition CSGBase.C:548

◆ 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
cellreference to cell to delete

Definition at line 362 of file CSGBase.C.

363{
364 if (!checkCellInBase(cell))
365 mooseError("Cell with name ",
366 cell.getName(),
367 " cannot be deleted as it is different from the cell of the same name in the "
368 "CSGBase instance.");
369
371 if (const auto * eng_unit = cellToEngUnit(cell))
372 _eng_unit_list.removeEngUnit(*eng_unit);
373 _cell_list.getCellListMap().erase(cell.getName());
374}
void prepareCellDeletion(const CSGCell &cell)
warn and remove cell from any universe that contains it
Definition CSGBase.C:340
std::unordered_map< std::string, std::unique_ptr< CSGCell > > & getCellListMap()
Get non-const map of all names to cells in cell list.
Definition CSGCellList.h:92
void removeEngUnit(const CSGEngUnit &unit)
Remove an engineering unit from this index by address.

◆ deleteEngUnit()

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

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

Parameters
unitreference to the engineering unit to delete

Definition at line 1327 of file CSGBase.C.

1328{
1329 if (!checkEngUnitInBase(unit))
1330 mooseError("Engineering unit with name ",
1331 unit.getName(),
1332 " cannot be deleted as it is different from the engineering unit of the same name "
1333 "in the CSGBase instance.");
1334
1335 // Delegate to the typed delete method which handles EngUnit index cleanup and type list erasure
1336 if (const auto * surf_unit = dynamic_cast<const CSGSurfaceEngUnit *>(&unit))
1337 deleteSurface(cast_ref<const CSGSurface &>(*surf_unit));
1338 else if (const auto * cell_unit = dynamic_cast<const CSGCellEngUnit *>(&unit))
1339 deleteCell(cast_ref<const CSGCell &>(*cell_unit));
1340 else if (const auto * univ_unit = dynamic_cast<const CSGUniverseEngUnit *>(&unit))
1341 deleteUniverse(cast_ref<const CSGUniverse &>(*univ_unit));
1342 else
1343 mooseError(
1344 "Engineering unit '", unit.getName(), "' has an unrecognized type and cannot be deleted.");
1345}
void deleteCell(const CSGCell &cell)
Remove a Cell object passed in by reference from the stored cell list.
Definition CSGBase.C:362
void deleteSurface(const CSGSurface &surface)
Remove a Surface object passed in by reference from the stored surface list.
Definition CSGBase.C:122
void deleteUniverse(const CSGUniverse &univ)
Remove a Universe object passed in by reference from the stored universe list.
Definition CSGBase.C:511

◆ 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
latticereference to lattice to delete

Definition at line 241 of file CSGBase.C.

242{
243 if (!checkLatticeInBase(lattice))
244 mooseError("Lattice with name ",
245 lattice.getName(),
246 " cannot be deleted as it is different from the lattice of the same name in the "
247 "CSGBase instance.");
248
249 // Check if lattice is used as fill in existing cells
250 for (const auto & cell_ref : _cell_list.getAllCells())
251 {
252 const auto & cell = cell_ref.get();
253 if ((cell.getFillType() == "LATTICE") && (cell.getFillLattice() == lattice))
254 mooseError("Cannot delete lattice with name ",
255 lattice.getName(),
256 " as it is used as the fill of cell with name ",
257 cell.getName());
258 }
259
260 _lattice_list.getLatticeListMap().erase(lattice.getName());
261}
std::unordered_map< std::string, std::unique_ptr< CSGLattice > > & getLatticeListMap()
Get map of all names to lattices in lattice list.

◆ 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
surfacereference to surface to delete

Definition at line 122 of file CSGBase.C.

123{
124 if (!checkSurfaceInBase(surface))
125 mooseError("Surface with name ",
126 surface.getName(),
127 " cannot be deleted as it is different from the surface of the same name in the "
128 "CSGBase instance.");
129
130 prepareSurfaceDeletion(surface);
131 if (const auto * eng_unit = surfaceToEngUnit(surface))
132 _eng_unit_list.removeEngUnit(*eng_unit);
133 _surface_list.getSurfaceListMap().erase(surface.getName());
134}
void prepareSurfaceDeletion(const CSGSurface &surface) const
error if surface is referenced in any cell region
Definition CSGBase.C:107
std::unordered_map< std::string, std::unique_ptr< CSGSurface > > & getSurfaceListMap()
Get non-const map of all names to surfaces in surface list.

◆ 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
univreference to universe to delete

Definition at line 511 of file CSGBase.C.

512{
513 if (!checkUniverseInBase(univ))
514 mooseError("Universe with name ",
515 univ.getName(),
516 " cannot be deleted as it is different from the universe of the same name in the "
517 "CSGBase instance.");
518
520 if (const auto * eng_unit = universeToEngUnit(univ))
521 _eng_unit_list.removeEngUnit(*eng_unit);
522 _universe_list.getUniverseListMap().erase(univ.getName());
523}
void prepareUniverseDeletion(const CSGUniverse &universe) const
error if universe is the root, used in any lattice, or used as a cell fill
Definition CSGBase.C:477
std::unordered_map< std::string, std::unique_ptr< CSGUniverse > > & getUniverseListMap()
Get non-const map of all names to universes in universe list.

◆ 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 1348 of file CSGBase.C.

1349{
1350 std::set<std::set<std::string>> all_type_sets;
1351 expandAllEngUnitsCycle(all_type_sets);
1352}
void expandAllEngUnitsCycle(std::set< std::set< std::string > > &all_type_sets)
Recursive implementation of expandAllEngUnits().
Definition CSGBase.C:1355

◆ 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_setsset of the sets of types seen in each pass of expandAllEngUnitsCycle

Definition at line 1355 of file CSGBase.C.

1356{
1357 // One call to this function is one pass: collect all current eng units, expand them, then
1358 // recurse if expansion created new units. Units created during a pass are not in this pass's
1359 // snapshot; they are handled in the next pass.
1360 //
1361 // Cycle check: if the same combination of unit types appeared at the start of a prior pass,
1362 // expansion is stuck repeating the same configuration. Tracking the full type-set (not
1363 // individual types) prevents false positives when a type reappears because it was produced
1364 // by a different type's expansion rather than its own.
1365 std::set<std::string> current_types;
1366 for (const auto & u : getAllEngUnits())
1367 current_types.insert(u.get().getUnitType());
1368
1369 if (all_type_sets.count(
1370 current_types)) // this expansion set was already captured which means we are cycling
1371 mooseError("Circular dependency detected in engineering unit expansion");
1372
1373 all_type_sets.insert(current_types);
1374
1375 // Snapshot raw pointers before expanding. Units are destroyed after expansion so iterating live
1376 // references would dangle.
1377 std::vector<const CSGSurfaceEngUnit *> surfs;
1378 std::vector<const CSGCellEngUnit *> cells;
1379 std::vector<const CSGUniverseEngUnit *> univs;
1380 for (const auto & u : getAllSurfaceEngUnits())
1381 surfs.push_back(&u.get());
1382 for (const auto & u : getAllCellEngUnits())
1383 cells.push_back(&u.get());
1384 for (const auto & u : getAllUniverseEngUnits())
1385 univs.push_back(&u.get());
1386
1387 // Expand all units in this pass
1388 for (const auto * s : surfs)
1389 expandEngUnit(*s);
1390 for (const auto * c : cells)
1391 expandEngUnit(*c);
1392 for (const auto * u : univs)
1393 expandEngUnit(*u);
1394
1395 // if engineering units exist after completion of all expansions above, then start the next "pass"
1396 // through this expansion process. This will create a new set of "current_types" to check.
1397 if (!getAllEngUnits().empty())
1398 expandAllEngUnitsCycle(all_type_sets);
1399}
std::vector< std::reference_wrapper< const CSGEngUnit > > getAllEngUnits() const
Get all engineering units of all types in CSGBase.
Definition CSGBase.h:629
CSGRegion expandEngUnit(const CSGSurfaceEngUnit &unit)
Expand a surface-like engineering unit into basic CSGSurface(s) and return the CSGRegion representing...
Definition CSGBase.C:1402
std::vector< std::reference_wrapper< const CSGSurfaceEngUnit > > getAllSurfaceEngUnits() const
Get all surface-like engineering units in CSGBase.
Definition CSGBase.h:639

◆ 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
unitidentifies 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 1450 of file CSGBase.C.

1451{
1452 // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
1453 // reference to the same object from the owning cell list to perform the expansion, which
1454 // mutates and consumes the unit (expandUnit() is non-const).
1455 auto & mutable_unit = cast_ref<CSGCellEngUnit &>(_cell_list.getCell(unit.getName()));
1456
1457 // Derived class populates an internal base object (owned by the unit) with the expanded cell (in
1458 // root) and any supports
1459 mutable_unit.expandUnit();
1460
1461 // Capture a reference to the expanded cell before the join. joinOtherBase transfers ownership
1462 // of the cell's unique_ptr but does not relocate the object, so the reference stays valid.
1463 // getExpandedCell also validates that root has exactly 1 cell.
1464 const CSGCell & expanded_cell = mutable_unit.getExpandedCell();
1465
1466 // Join the unit's base object: 1-param merges root cells into this root
1467 joinOtherBase(mutable_unit.releaseBase(), false);
1468
1469 // Propagate any stored transformations from the EngUnit to the expanded cell
1470 const auto & trans = cast_ref<const CSGCell &>(mutable_unit).getTransformations();
1471 if (!trans.empty())
1472 {
1473 CSGCell & mutable_cell = _cell_list.getCell(expanded_cell.getName());
1474 for (const auto & [trans_type, values] : trans)
1475 mutable_cell.addTransformation(trans_type, values);
1476 }
1477
1478 // The join added the expanded cell to this root via root-merge; remove it so
1479 // replaceCellRefs() can place it in the correct universe(s)
1480 if (getRootUniverse().hasCell(expanded_cell.getName()))
1481 removeCellFromUniverse(getRootUniverse(), expanded_cell);
1482
1483 // Replace all references to the CSGCellEngUnit in universes with the new expanded CSGCell
1484 replaceCellRefs(cast_ref<const CSGCell &>(mutable_unit), expanded_cell);
1485
1486 // Remove the EngUnit (destroyed here, no more references to it after replaceCellRefs)
1487 deleteEngUnit(unit);
1488 return expanded_cell;
1489}
void joinOtherBase(std::unique_ptr< CSGBase > base, const bool ignore_identical_components)
Join another CSGBase object to this one.
Definition CSGBase.C:792
bool hasCell(const std::string &name) const
Check if a cell with given name exists in CSGBase object.
Definition CSGBase.h:223
void removeCellFromUniverse(const CSGUniverse &universe, const CSGCell &cell)
Remove a cell from an existing universe.
Definition CSGBase.C:556
void replaceCellRefs(const CSGCell &old_cell, const CSGCell &new_cell)
Replace all old_cell references with new_cell across all universes in the base.
Definition CSGBase.C:1592
void deleteEngUnit(const CSGEngUnit &unit)
Remove an engineering unit passed in by reference from the stored engineering unit list.
Definition CSGBase.C:1327

◆ 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
unitidentifies 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 1402 of file CSGBase.C.

1403{
1404 // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
1405 // reference to the same object from the owning surface list to perform the expansion, which
1406 // mutates and consumes the unit (expandUnit() is non-const).
1407 auto & mutable_unit = cast_ref<CSGSurfaceEngUnit &>(_surface_list.getSurface(unit.getName()));
1408
1409 // Derived class creates the CSGSurface object(s) in the unit's base object and sets
1410 // _expanded_region
1411 mutable_unit.expandUnit();
1412
1413 // check that the base object that was generated has only surfaces and no cells or universes
1414 // (except root).
1415 auto unit_base = mutable_unit.getBase();
1416 if ((unit_base.getAllCells().size() > 0) || (unit_base.getAllUniverses().size() > 1))
1417 mooseError("CSGSurfaceEngineering unit ",
1418 mutable_unit.getName(),
1419 " of type ",
1420 mutable_unit.getUnitType(),
1421 " contains either cells or universes (beyond the root universe) after expansion, "
1422 "but should only contain surfaces.");
1423
1424 // Join the unit's base object into this; transfers surfaces (and any other objects) during merge.
1425 joinOtherBase(mutable_unit.releaseBase(), false);
1426
1427 // Derived class provides the expanded region formed by the expanded surfaces
1428 CSGRegion expanded_region = mutable_unit.getExpandedRegion();
1429
1430 // Propagate any stored transformations from the EngUnit to all new expanded surfaces
1431 const auto & trans = cast_ref<const CSGSurface &>(mutable_unit).getTransformations();
1432 if (!trans.empty())
1433 for (const auto & surf_ref : expanded_region.getSurfaces())
1434 {
1435 CSGSurface & mutable_surf = _surface_list.getSurface(surf_ref.get().getName());
1436 for (const auto & [trans_type, values] : trans)
1437 mutable_surf.addTransformation(trans_type, values);
1438 }
1439
1440 // Replace every CSGSurfaceEngUnit reference in regions of CSGCells with the expanded sub-region
1441 replaceSurfaceRefsWithRegion(cast_ref<const CSGSurface &>(mutable_unit), expanded_region);
1442
1443 // Remove the EngUnit (destroyed here, no more references to it after
1444 // replaceSurfaceRefsWithRegion)
1445 deleteEngUnit(unit);
1446 return expanded_region;
1447}
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 ba...
Definition CSGBase.C:1607

◆ 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
unitidentifies 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 1492 of file CSGBase.C.

1493{
1494 auto unit_name = unit.getName();
1495
1496 // unit is const because the eng-unit API exposes only const references; re-fetch a mutable
1497 // reference to the same object from the owning universe list to perform the expansion, which
1498 // mutates and consumes the unit (expandUnit() is non-const).
1499 auto & mutable_unit = cast_ref<CSGUniverseEngUnit &>(_universe_list.getUniverse(unit_name));
1500
1501 // Derived class populates the unit's base object; the root of this base is the expanded universe
1502 // that will be used to replace this universe unit
1503 mutable_unit.expandUnit();
1504
1505 // Capture the name of the expanded universe (the unit base's root universe) before the join
1506 // getExpandedUniverse will validate that the root contains cells and was properly
1507 // implemented/expanded such that incoming cells and universes are all linked to the root.
1508 auto & pre_join_univ = mutable_unit.getExpandedUniverse();
1509 auto expanded_name = pre_join_univ.getName();
1510
1511 // Check that the expanded name for the new root universe has been updated to something other than
1512 // ROOT_UNIVERSE. If name was not already updated, issue a warning (debug) and update the name
1513 // automatically. This only matters if the current root universe is also named ROOT_UNIVERSE
1514 // so we only need to check if the name matches the root universe name (rather than explicitly
1515 // checking for the name ROOT_UNIVERSE).
1516
1517 // release the incoming base object to be able to rename if necessary
1518 auto unit_base = mutable_unit.releaseBase();
1519 if (expanded_name == getRootUniverse().getName())
1520 {
1521 // root universe must be renamed
1522 auto new_expanded_name = unit_name + "_expanded_root";
1523#ifdef DEBUG
1524 mooseInfoRepeated("Universe engineering unit " + unit_name +
1525 " has an expanded root universe named " + expanded_name +
1526 ", which is identical to the name of the current root universe. The expanded "
1527 "universe will be renamed " +
1528 new_expanded_name + ".");
1529#endif
1530
1531 unit_base->renameRootUniverse(new_expanded_name);
1532 expanded_name = new_expanded_name;
1533 }
1534
1535 // Join the unit's base into this: all objects are transferred and the incoming root is added as
1536 // a named non-root universe (expanded_name). If the root universe's name is not unique (i.e. it
1537 // was left named ROOT_UNIVERSE), this will throw an error.
1538 joinOtherBase(std::move(unit_base), false, expanded_name);
1539
1540 // must get this by name after joining because the join method rebuilds the universe and the
1541 // previous reference from getExpandedUniverse is not valid anymore.
1542 const CSGUniverse & expanded_univ = getUniverseByName(expanded_name);
1543
1544 // Propagate any stored transformations from the EngUnit to the new expanded universe
1545 const auto & trans = cast_ref<const CSGUniverse &>(mutable_unit).getTransformations();
1546 if (!trans.empty())
1547 {
1548 CSGUniverse & mutable_univ = _universe_list.getUniverse(expanded_univ.getName());
1549 for (const auto & [trans_type, values] : trans)
1550 mutable_univ.addTransformation(trans_type, values);
1551 }
1552
1553 // Replace references in cell fills, lattice maps and outers, and the root universe
1554 replaceUniverseRefs(cast_ref<const CSGUniverse &>(mutable_unit), expanded_univ);
1555
1556 // Remove the EngUnit (destroyed here, no more references to it after replaceUniverseRefs)
1557 deleteEngUnit(unit);
1558 return expanded_univ;
1559}
void mooseInfoRepeated(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
Definition MooseError.h:409
const CSGUniverse & getUniverseByName(const std::string &name)
Get a universe object by name.
Definition CSGBase.h:376
void replaceUniverseRefs(const CSGUniverse &old_univ, const CSGUniverse &new_univ)
Replace all cell fills and lattice elements/outers referencing old_univ with new_univ.
Definition CSGBase.C:1562

◆ FRIEND_TEST() [1/7]

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

◆ FRIEND_TEST() [2/7]

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

◆ FRIEND_TEST() [3/7]

CSG::CSGBase::FRIEND_TEST ( CSGBaseTest  ,
testCellUniverseMembership   
)
private

◆ FRIEND_TEST() [4/7]

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

Friends for unit testing.

◆ FRIEND_TEST() [5/7]

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

◆ FRIEND_TEST() [6/7]

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

◆ FRIEND_TEST() [7/7]

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 1622 of file CSGBase.C.

1623{
1624 checkGeometry();
1625
1626 nlohmann::json csg_json;
1627
1628 csg_json["surfaces"] = {}; // if empty (all are eng units), this will be deleted later
1629 csg_json["cells"] = {}; // if empty (all are eng units), this will be deleted later
1630 csg_json["universes"] = {}; // root universe always exists, so this does not get deleted later
1631
1632 // get all surfaces information
1633 auto all_surfs = getAllSurfaces();
1634 for (const CSGSurface & s : all_surfs)
1635 {
1636 if (surfaceToEngUnit(s))
1637 continue; // engineering units are written in a separate section
1638 const auto & surf_name = s.getName();
1639 const auto & coeffs = s.getCoeffs();
1640 csg_json["surfaces"][surf_name] = {{"type", s.getSurfaceType()}, {"coefficients", {}}};
1641 for (const auto & c : coeffs)
1642 csg_json["surfaces"][surf_name]["coefficients"][c.first] = c.second;
1643 // include any information about transformations if present
1644 if (s.getTransformations().size() > 0)
1645 csg_json["surfaces"][surf_name]["transformations"] = s.getTransformationsAsStrings();
1646 }
1647
1648 // Drop the surfaces section if nothing was written (e.g. all surfaces were engineering units,
1649 // which are output in the units section instead)
1650 if (csg_json["surfaces"].empty())
1651 csg_json.erase("surfaces");
1652
1653 // Print out cell information
1654 auto all_cells = getAllCells();
1655 for (const CSGCell & c : all_cells)
1656 {
1657 if (cellToEngUnit(c))
1658 continue; // engineering units are written in a separate section
1659 const auto & cell_name = c.getName();
1660 const auto & cell_region_infix = c.getRegion().toInfixJSON();
1661 const auto & cell_region_postfix = c.getRegion().toPostfixStringList();
1662 const auto & cell_filltype = c.getFillType();
1663 const auto & fill_name = c.getFillName();
1664 csg_json["cells"][cell_name]["filltype"] = cell_filltype;
1665 csg_json["cells"][cell_name]["region_infix"] = cell_region_infix;
1666 csg_json["cells"][cell_name]["region_postfix"] = cell_region_postfix;
1667 csg_json["cells"][cell_name]["fill"] = fill_name;
1668 // include any information about transformations if present
1669 if (c.getTransformations().size())
1670 csg_json["cells"][cell_name]["transformations"] = c.getTransformationsAsStrings();
1671 }
1672
1673 // Drop the cells section if nothing was written (e.g. all cells were engineering units,
1674 // which are output in the units section instead)
1675 if (csg_json["cells"].empty())
1676 csg_json.erase("cells");
1677
1678 // Print out universe information
1679 auto all_univs = getAllUniverses();
1680 for (const CSGUniverse & u : all_univs)
1681 {
1682 if (universeToEngUnit(u))
1683 continue; // engineering units are written in a separate section
1684 const auto & univ_name = u.getName();
1685 const auto & univ_cells = u.getAllCells();
1686 csg_json["universes"][univ_name]["cells"] = {};
1687 for (const CSGCell & c : univ_cells)
1688 csg_json["universes"][univ_name]["cells"].push_back(c.getName());
1689 if (u.isRoot())
1690 csg_json["universes"][univ_name]["root"] = u.isRoot();
1691 // include any information about transformations if present
1692 if (u.getTransformations().size())
1693 csg_json["universes"][univ_name]["transformations"] = u.getTransformationsAsStrings();
1694 }
1695
1696 // print out lattice information if lattices exist
1697 auto all_lats = getAllLattices();
1698 if (all_lats.size())
1699 {
1700 csg_json["lattices"] = {};
1701 for (const CSGLattice & lat : all_lats)
1702 {
1703 const auto & lat_name = lat.getName();
1704 csg_json["lattices"][lat_name] = {};
1705 csg_json["lattices"][lat_name]["type"] = lat.getType();
1706 const auto & outer_type = lat.getOuterType();
1707 csg_json["lattices"][lat_name]["outertype"] = outer_type;
1708 if (outer_type == "UNIVERSE")
1709 csg_json["lattices"][lat_name]["outer"] = lat.getOuterUniverse().getName();
1710 else if (outer_type == "CSG_MATERIAL")
1711 csg_json["lattices"][lat_name]["outer"] = lat.getOuterMaterial();
1712 // write out any additional attributes
1713 csg_json["lattices"][lat_name]["attributes"] = {};
1714 const auto & lat_attrs = lat.getAttributes();
1715 for (const auto & attr : lat_attrs)
1716 csg_json["lattices"][lat_name]["attributes"][attr.first] = attr.second;
1717 // write the map of universe names: list of lists
1718 csg_json["lattices"][lat_name]["universes"] = lat.getUniverseNameMap();
1719 // include any information about transformations if present
1720 if (lat.getTransformations().size())
1721 csg_json["lattices"][lat_name]["transformations"] = lat.getTransformationsAsStrings();
1722 }
1723 }
1724
1725 // include engineering units if they exist
1726 auto all_units = getAllEngUnits();
1727 if (all_units.size())
1728 {
1729 csg_json["units"] = {};
1730 for (const CSGEngUnit & unit : all_units)
1731 {
1732 const auto & unit_name = unit.getName();
1733 csg_json["units"][unit_name] = {};
1734 // behavior and type
1735 csg_json["units"][unit_name]["unit_type"] = unit.getUnitType();
1736 csg_json["units"][unit_name]["behavior"] = unit.getBehavior();
1737 // any unit-specific attributes
1738 csg_json["units"][unit_name]["attributes"] = {};
1739 const auto & unit_attrs = unit.getAttributes();
1740 for (const auto & attr : unit_attrs)
1741 csg_json["units"][unit_name]["attributes"][attr.first] = attr.second;
1742 if (unit.getTransformations().size())
1743 csg_json["units"][unit_name]["transformations"] = unit.getTransformationsAsStrings();
1744 }
1745 }
1746
1747 return csg_json;
1748}
void checkGeometry() const
Check that the geometry is valid for output and conversion to downstream codes.
Definition CSGBase.C:1256
std::vector< std::reference_wrapper< const CSGLattice > > getAllLattices() const
Get all lattice objects.
Definition CSGBase.h:491

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

650 {
652 }
std::vector< std::reference_wrapper< const CSGCellEngUnit > > getAllCellEngUnits() const
Get all cell-like engineering units.

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.

205 {
206 return _cell_list.getAllCells();
207 }
std::vector< std::reference_wrapper< const CSGCell > > getAllCells() const
Get all the cells in CSGBase instance.
Definition CSGCellList.C:83

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

630 {
632 }
std::vector< std::reference_wrapper< const CSGEngUnit > > getAllEngUnits() const
Get all engineering units of all types in the list.

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

492 {
494 }
std::vector< std::reference_wrapper< const CSGLattice > > getAllLattices() const
Get all the lattices in CSGBase instance.

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

640 {
642 }
std::vector< std::reference_wrapper< const CSGSurfaceEngUnit > > getAllSurfaceEngUnits() const
Get all surface-like engineering units.

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

102 {
104 }
std::vector< std::reference_wrapper< const CSGSurface > > getAllSurfaces() const
Get list of references to all surfaces in surface list.

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

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

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.

366 {
368 }
std::vector< std::reference_wrapper< const CSGUniverse > > getAllUniverses() const
Get all the universes in CSGBase instance.

◆ getCellByName()

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

Get a Cell object by name.

Parameters
namecell 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 1005 of file CSGBase.h.

1005{ 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 998 of file CSGBase.h.

998{ 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
nameengineering unit name
Returns
const reference to the engineering unit

Definition at line 597 of file CSGBase.h.

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

◆ getEngUnitList()

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

Get a const reference to the CSGEngUnitList object.

Returns
CSGEngUnitList

Definition at line 1098 of file CSGBase.h.

1098{ 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
namelattice name
Returns
reference to CSGLattice object

Definition at line 509 of file CSGBase.h.

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

◆ getLatticeList() [1/2]

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

Get the CSGLatticeList object.

Returns
CSGLatticeList

Definition at line 1033 of file CSGBase.h.

1033{ 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 1026 of file CSGBase.h.

1026{ 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
univReference to universe under consideration
linked_universe_namesList of universe names linked to current universe
linked_cell_namesList of cell names linked to current universe
linked_surface_namesList of surface names linked to current universe

Definition at line 1286 of file CSGBase.C.

1290{
1291 // A universe referenced from many lattice positions only needs its subtree walked once
1292 if (!linked_universe_names.insert(univ.getName()).second)
1293 return;
1294 linked_universe_names.insert(univ.getName());
1295 const auto & univ_cells = univ.getAllCells();
1296 for (const CSGCell & cell : univ_cells)
1297 {
1298 linked_cell_names.insert(cell.getName());
1299 for (const CSGSurface & cell_surf : cell.getRegion().getSurfaces())
1300 linked_surface_names.insert(cell_surf.getName());
1301
1302 if (cell.getFillType() == "UNIVERSE")
1304 cell.getFillUniverse(), linked_universe_names, linked_cell_names, linked_surface_names);
1305 else if (cell.getFillType() == "LATTICE")
1306 {
1307 const auto & lattice = cell.getFillLattice();
1308 for (const auto & univ_list : lattice.getUniverses())
1309 for (const auto & univ_ref : univ_list)
1310 {
1311 const CSGUniverse & lattice_univ = univ_ref.get();
1313 lattice_univ, linked_universe_names, linked_cell_names, linked_surface_names);
1314 }
1315
1316 if (lattice.getOuterType() == "UNIVERSE")
1317 {
1318 const CSGUniverse & outer_univ = lattice.getOuterUniverse();
1320 outer_univ, linked_universe_names, linked_cell_names, linked_surface_names);
1321 }
1322 }
1323 }
1324}

◆ 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(); }
const CSGUniverse & getRoot() const
Get the root universe.

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
namesurface name
Returns
reference to CSGSurface object

Definition at line 945 of file CSGBase.h.

945{ return _surface_list.getSurface(name); }

◆ getSurfaceByName()

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

Get a Surface object by name.

Parameters
namesurface name
Returns
reference to CSGSurface object

Definition at line 112 of file CSGBase.h.

113 {
114 return _surface_list.getSurface(name);
115 }

◆ getSurfaceList() [1/2]

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

Get a non-const reference to the CSGSurfaceList object.

Returns
CSGSurfaceList

Definition at line 991 of file CSGBase.h.

991{ 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 984 of file CSGBase.h.

984{ 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
nameuniverse name
Returns
reference to CSGUniverse object

Definition at line 376 of file CSGBase.h.

377 {
378 return _universe_list.getUniverse(name);
379 }

◆ getUniverseList() [1/2]

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

Get a non-const reference to the CSGUniverseList object.

Returns
CSGUniverseList

Definition at line 1019 of file CSGBase.h.

1019{ 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 1012 of file CSGBase.h.

1012{ 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
namecell 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
nameengineering 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
namelattice 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
namesurface 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); }
bool hasSurface(const std::string &name) const
return whether surface with given name exists in surface list

◆ hasUniverse()

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

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

Parameters
nameuniverse 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_listCSGCellList from a separate CSGBase object
ignore_identical_cellsif true, will skip adding identical cells to the CSGBase object

Definition at line 982 of file CSGBase.C.

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

◆ joinLatticeList()

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

join a separate CSGLatticeList object to this one

Parameters
lattice_listCSGLatticeList from a separate CSGBase object
ignore_identical_latticesif true, will skip adding identical lattices to the CSGBase object

Definition at line 990 of file CSGBase.C.

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

◆ 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
basepointer to a different CSGBase object
ignore_identical_componentsif true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object

Definition at line 792 of file CSGBase.C.

793{
794 // If we are ignoring identical incoming CSG components, we need to update any references
795 // stored by these components to point to the references of the pre-existing CSGBase object
796 if (ignore_identical_components)
798 joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
799 joinCellList(base->getCellList(), ignore_identical_components);
800 joinLatticeList(base->getLatticeList(), ignore_identical_components);
801 joinUniverseList(base->getUniverseList(), ignore_identical_components);
802 rebuildEngUnitList(); // finds all engineering units again, allowing us to keep any ignored
803 // surfaces that were removed from the surface list out of this list
804}
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 in...
Definition CSGBase.C:1016
void updateIncomingCSGReferences(CSGBase &incoming_base)
update references of incoming CSGbase to point to those of existing CSGBase object.
Definition CSGBase.C:843
void joinCellList(CSGCellList &cell_list, const bool ignore_identical_cells)
join a separate CSGCellList object to this one
Definition CSGBase.C:982
void joinLatticeList(CSGLatticeList &lattice_list, const bool ignore_identical_lattices)
join a separate CSGLatticeList object to this one
Definition CSGBase.C:990
void joinSurfaceList(CSGSurfaceList &surf_list, const bool ignore_identical_surfaces)
join a separate CSGSurfaceList object to this one
Definition CSGBase.C:974

◆ 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
basepointer to a different CSGBase object
ignore_identical_componentsif true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object
new_root_name_basenew name for universe generated from this root universe
new_root_name_joinnew name for the universe generated from the incoming root universe

Definition at line 824 of file CSGBase.C.

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

◆ 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
basepointer to a different CSGBase object
ignore_identical_componentsif true, will skip adding identical components (surfaces, cells, universes, lattices) to the CSGBase object
new_root_name_joinnew name for the universe generated from the incoming root universe

Definition at line 807 of file CSGBase.C.

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

◆ joinSurfaceList()

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

join a separate CSGSurfaceList object to this one

Parameters
surf_listCSGSurfaceList from a separate CSGBase object
ignore_identical_surfacesif true, will skip adding identical surfaces to the CSGBase object

Definition at line 974 of file CSGBase.C.

975{
976 auto & surf_list_map = surf_list.getSurfaceListMap();
977 for (auto & s : surf_list_map)
978 _surface_list.addSurface(std::move(s.second), ignore_identical_surfaces);
979}
const CSGSurface & addSurface(std::unique_ptr< CSGSurface > surf)
add a unique surface pointer to this base instance
Definition CSGBase.C:97

◆ 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_listCSGUniverseList from a separate CSGBase object
ignore_identical_universesif true, will skip adding identical universes to the CSGBase object

Definition at line 1016 of file CSGBase.C.

1017{
1018 // case 1: incoming root is joined into existing root; no new universes are created
1019 auto & univ_list_map = univ_list.getUniverseListMap();
1020 auto & root = getRootUniverse(); // this root universe
1021 for (auto & u : univ_list_map)
1022 {
1023 if (u.second->isRoot())
1024 {
1025 // add existing cells to current root instead of creating new universe
1026 auto all_cells = u.second->getAllCells();
1027 for (auto & cell : all_cells)
1028 addCellToUniverse(root, cell);
1029 }
1030 else // unique non-root universe to add to list
1031 _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
1032 }
1033}

◆ 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_listCSGUniverseList from a separate CSGBase object
ignore_identical_universesif true, will skip adding identical lattices to the CSGBase object
new_root_name_basenew name for universe generated from this root universe
new_root_name_incomingnew name for the universe generated from the incoming root universe

Definition at line 1058 of file CSGBase.C.

1062{
1063 // case 3: each root universe becomes a new universe and a new root is created
1064
1065 // make a new universe from the existing root universe
1066 auto & root = getRootUniverse();
1067 auto root_cells = root.getAllCells();
1068 createUniverse(new_root_name_base, root_cells);
1069 removeCellsFromUniverse(root, root_cells);
1070
1071 // add incoming universes to current Base
1072 auto & all_univs = univ_list.getUniverseListMap();
1073 for (auto & u : all_univs)
1074 {
1075 if (u.second->isRoot())
1076 {
1077 // create new universe from incoming root universe
1078 auto all_cells = u.second->getAllCells();
1079 createUniverse(new_root_name_incoming, all_cells);
1080 }
1081 else // unique non-root universe to add to list
1082 _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
1083 }
1084}
void removeCellsFromUniverse(const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell > > &cells)
Remove a list of cells from an existing universe.
Definition CSGBase.C:575

◆ 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_listCSGUniverseList from a separate CSGBase object
ignore_identical_universesif true, will skip adding identical universes to the CSGBase object
new_root_name_incomingnew name for the universe generated from the incoming root universe

Definition at line 1036 of file CSGBase.C.

1039{
1040 // case 2: incoming root is turned into new universe and existing root remains root
1041
1042 // add incoming universes to current Base
1043 auto & all_univs = univ_list.getUniverseListMap();
1044 for (auto & u : all_univs)
1045 {
1046 if (u.second->isRoot())
1047 {
1048 // create new universe from incoming root universe
1049 auto all_cells = u.second->getAllCells();
1050 createUniverse(new_root_name_incoming, all_cells);
1051 }
1052 else // unique non-root universe to add to list
1053 _universe_list.addUniverse(std::move(u.second), ignore_identical_universes);
1054 }
1055}

◆ operator!=()

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

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

Definition at line 1769 of file CSGBase.C.

1770{
1771 return !(*this == other);
1772}

◆ operator==()

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

Operator overload for checking if two CSGBase objects are equal.

Definition at line 1751 of file CSGBase.C.

1752{
1753 const auto & surf_list = this->getSurfaceList();
1754 const auto & other_surf_list = other.getSurfaceList();
1755 const auto & cell_list = this->getCellList();
1756 const auto & other_cell_list = other.getCellList();
1757 const auto & univ_list = this->getUniverseList();
1758 const auto & other_univ_list = other.getUniverseList();
1759 const auto & lat_list = this->getLatticeList();
1760 const auto & other_lat_list = other.getLatticeList();
1761 const auto & eng_unit_list = this->getEngUnitList();
1762 const auto & other_eng_unit_list = other.getEngUnitList();
1763 return (surf_list == other_surf_list) && (cell_list == other_cell_list) &&
1764 (univ_list == other_univ_list) && (lat_list == other_lat_list) &&
1765 (eng_unit_list == other_eng_unit_list);
1766}
const CSGSurfaceList & getSurfaceList() const
Get a const reference to the CSGSurfaceList object.
Definition CSGBase.h:984
const CSGEngUnitList & getEngUnitList() const
Get a const reference to the CSGEngUnitList object.
Definition CSGBase.h:1098

◆ prepareCellDeletion()

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

warn and remove cell from any universe that contains it

Definition at line 340 of file CSGBase.C.

341{
342 for (const auto & univ_ref : _universe_list.getAllUniverses())
343 {
344 const auto & univ = univ_ref.get();
345 for (const auto & univ_cell : univ.getAllCells())
346 if (cell == univ_cell.get())
347 {
348 // must remove from root intentionally too, but don't warn in this case (too noisy for
349 // expected behavior)
350 if (univ != getRootUniverse())
351 mooseWarning("Removing cell ",
352 cell.getName(),
353 " from universe with name ",
354 univ.getName(),
355 " before cell deletion.");
356 _universe_list.getUniverse(univ.getName()).removeCell(cell.getName());
357 }
358 }
359}
void removeCell(const std::string &name)
remove a cell of the specified name from the universe
Definition CSGUniverse.C:60

◆ prepareSurfaceDeletion()

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

error if surface is referenced in any cell region

Definition at line 107 of file CSGBase.C.

108{
109 for (const auto & cell_ref : _cell_list.getAllCells())
110 {
111 const auto & cell = cell_ref.get();
112 for (const auto & region_surf : cell.getRegion().getSurfaces())
113 if (region_surf.get() == surface)
114 mooseError("Cannot delete surface with name ",
115 surface.getName(),
116 " as it is used in region definition of cell with name ",
117 cell.getName());
118 }
119}

◆ 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 477 of file CSGBase.C.

478{
479 if (univ == getRootUniverse())
480 mooseError("Cannot delete root universe from CSGBase instance");
481
482 // Check if universe is used in any existing lattices
483 for (const auto & lat : _lattice_list.getAllLattices())
484 {
485 for (const auto & lat_univ : lat.get().getUniqueUniverses())
486 if (univ == lat_univ.get())
487 mooseError("Cannot delete universe with name ",
488 univ.getName(),
489 " as it is used in lattice with name ",
490 lat.get().getName());
491 if ((lat.get().getOuterType() == "UNIVERSE") && (lat.get().getOuterUniverse() == univ))
492 mooseError("Cannot delete universe with name ",
493 univ.getName(),
494 " as it is used as the outer universe of lattice with name ",
495 lat.get().getName());
496 }
497
498 // Check if universe is used as fill in existing cells
499 for (const auto & cell_ref : _cell_list.getAllCells())
500 {
501 const auto & cell = cell_ref.get();
502 if ((cell.getFillType() == "UNIVERSE") && (cell.getFillUniverse() == univ))
503 mooseError("Cannot delete universe with name ",
504 univ.getName(),
505 " as it is used as the fill of cell with name ",
506 cell.getName());
507 }
508}

◆ 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 998 of file CSGBase.C.

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

Referenced by CSGBase().

◆ removeCellFromUniverse()

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

Remove a cell from an existing universe.

Parameters
universeuniverse from which to remove the cell
cellcell to remove

Definition at line 556 of file CSGBase.C.

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

◆ 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
universeuniverse from which to remove the cells
cellslist of references to cells to remove

Definition at line 575 of file CSGBase.C.

577{
578 for (auto & c : cells)
579 removeCellFromUniverse(universe, c);
580}

◆ renameCell()

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

rename the specified cell

Parameters
cellreference to CSGCell to rename
namenew name

Definition at line 1180 of file CSGBase.C.

1181{
1182 // if cell is actually an engineering unit, we have to also check that no other units have the
1183 // same name already
1184 if (cellToEngUnit(cell))
1185 if (_eng_unit_list.hasEngUnit(name))
1186 mooseError("Cannot rename cell " + cell.getName() + " to " + name + ". " + cell.getName() +
1187 " is an engineering unit and a unit with name " + name + " already exists.");
1188
1189 _cell_list.renameCell(cell, name);
1190}
void renameCell(const CSGCell &cell, const std::string &name)
rename the specified cell
Definition CSGCellList.C:92

◆ renameEngUnit()

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

Rename the specified engineering unit.

Parameters
unitreference to engineering unit to rename
namenew name

Definition at line 1149 of file CSGBase.C.

1150{
1151 // Rename in the owning type list (updates the object's name and the type list map key).
1152 // The EngUnit index stores raw pointers; because the object's name is updated in-place,
1153 // no index update is needed.
1154 if (const auto * surf = dynamic_cast<const CSGSurfaceEngUnit *>(&unit))
1155 renameSurface(*surf, name);
1156 else if (const auto * cell = dynamic_cast<const CSGCellEngUnit *>(&unit))
1157 renameCell(*cell, name);
1158 else if (const auto * univ = dynamic_cast<const CSGUniverseEngUnit *>(&unit))
1159 renameUniverse(*univ, name);
1160 else
1161 mooseError(
1162 "Engineering unit '", unit.getName(), "' has an unrecognized type and cannot be renamed.");
1163}
void renameSurface(const CSGSurface &surface, const std::string &name)
rename the specified surface
Definition CSGBase.C:1166
void renameUniverse(const CSGUniverse &universe, const std::string &name)
rename the specified universe
Definition CSGBase.C:1193
void renameCell(const CSGCell &cell, const std::string &name)
rename the specified cell
Definition CSGBase.C:1180

◆ renameLattice()

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

rename the lattice

Parameters
latticelattice to rename
namenew name

Definition at line 456 of file CSGBase.h.

457 {
458 _lattice_list.renameLattice(lattice, name);
459 }
void renameLattice(const CSGLattice &lattice, const std::string &name)
rename the specified lattice

◆ renameRootUniverse()

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

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

Parameters
namenew name for the root universe

Definition at line 284 of file CSGBase.h.

285 {
287 }

◆ renameSurface()

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

rename the specified surface

Parameters
surfaceCSGSurface to rename
namenew name

Definition at line 1166 of file CSGBase.C.

1167{
1168 // if surface is actually an engineering unit, we have to also check that no other units have the
1169 // same name already
1170 if (surfaceToEngUnit(surface))
1171 if (_eng_unit_list.hasEngUnit(name))
1172 mooseError("Cannot rename surface " + surface.getName() + " to " + name + ". " +
1173 surface.getName() + " is an engineering unit and a unit with name " + name +
1174 " already exists.");
1175
1176 _surface_list.renameSurface(surface, name);
1177}
void renameSurface(const CSGSurface &surface, const std::string &name)
rename the specified surface

◆ renameUniverse()

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

rename the specified universe

Parameters
universereference to CSGUniverse to rename
namenew name

Definition at line 1193 of file CSGBase.C.

1194{
1195 // if universe is actually an engineering unit, we have to also check that no other units have the
1196 // same name already
1197 if (universeToEngUnit(universe))
1198 if (_eng_unit_list.hasEngUnit(name))
1199 mooseError("Cannot rename universe " + universe.getName() + " to " + name + ". " +
1200 universe.getName() + " is an engineering unit and a unit with name " + name +
1201 " already exists.");
1202
1203 _universe_list.renameUniverse(universe, name);
1204}
void renameUniverse(const CSGUniverse &universe, const std::string &name)
rename the specified universe

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 1592 of file CSGBase.C.

1593{
1594 for (const auto & univ_ref : getAllUniverses())
1595 {
1596 const CSGUniverse & univ = univ_ref.get();
1597 for (const auto & cell_ref : univ.getAllCells())
1598 if (&cell_ref.get() == &old_cell)
1599 {
1600 removeCellFromUniverse(univ, old_cell);
1601 addCellToUniverse(univ, new_cell);
1602 }
1603 }
1604}

◆ 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_refsmap of cell names to cell references that will be used for replacement
baseCSGBase object that contains references that should be updated

Definition at line 903 of file CSGBase.C.

906{
907 // Update cell references of universes to those of this base
908 for (auto & [univ_name, univ_ptr] : base.getUniverseList().getUniverseListMap())
909 for (auto & [cell_name, cell_ref] : identical_cell_refs)
910 if (univ_ptr->hasCell(cell_name))
911 {
912 univ_ptr->removeCell(cell_name);
913 univ_ptr->addCell(cell_ref);
914 }
915}

◆ 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_refsmap of lattice names to lattice references that will be used for replacement
baseCSGBase object that contains references that should be updated

Definition at line 955 of file CSGBase.C.

958{
959 // Update lattice references of cells to those of this base
960 for (auto & [cell_name, cell_ptr] : base.getCellList().getCellListMap())
961 {
962 const auto fill_type = cell_ptr->getFillType();
963 const auto fill_name = cell_ptr->getFillName();
964 if ((fill_type == "LATTICE") &&
965 (identical_lattice_refs.find(fill_name) != identical_lattice_refs.end()))
966 {
967 const CSGLattice * lat_ptr = &identical_lattice_refs.at(fill_name).get();
968 cell_ptr->updateCellFill(lat_ptr);
969 }
970 }
971}

◆ 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_refsmap of surface names to surface references that will be used for replacement
baseCSGBase object that contains references that should be updated

Definition at line 893 of file CSGBase.C.

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

◆ 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 1607 of file CSGBase.C.

1608{
1609 for (const auto & cell_ref : getAllCells())
1610 {
1611 const CSGCell & cell = cell_ref.get();
1612 CSGRegion new_region = cell.getRegion();
1613 if (new_region.getRegionType() == CSGRegion::RegionType::EMPTY)
1614 continue; // cell units do not have a region so skip (can also skip if a regular cell has an
1615 // empty region)
1616 new_region.replaceWithSubRegion(old_surf, sub_region);
1617 updateCellRegion(cell, new_region);
1618 }
1619}
void updateCellRegion(const CSGCell &cell, const CSGRegion &region)
change the region of the specified cell
Definition CSGBase.C:377

◆ 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 1562 of file CSGBase.C.

1563{
1564 // 1. Cell fills
1565 for (const auto & cell_ref : getAllCells())
1566 {
1567 const CSGCell & cell = cell_ref.get();
1568 if (cell.getFillType() == "UNIVERSE" && cell.getFillUniverse() == old_univ)
1569 updateCellFill(cell, &new_univ);
1570 }
1571
1572 // 2. Lattice universe maps and outer fills
1573 for (const auto & lat_ref : getAllLattices())
1574 {
1575 const CSGLattice & lat = lat_ref.get();
1576 if (lat.getOuterType() == "UNIVERSE" && lat.getOuterUniverse() == old_univ)
1577 setLatticeOuter(lat, new_univ);
1578
1579 auto lat_map = lat.getUniverses();
1580 for (std::size_t row = 0; row < lat_map.size(); ++row)
1581 for (std::size_t col = 0; col < lat_map[row].size(); ++col)
1582 if (lat_map[row][col].get() == old_univ)
1583 setUniverseAtLatticeIndex(lat, new_univ, {static_cast<int>(row), static_cast<int>(col)});
1584 }
1585
1586 // 3. Root universe pointer in universe list
1587 if (getRootUniverse() == old_univ)
1588 _universe_list._root_universe = &new_univ;
1589}
void setUniverseAtLatticeIndex(const CSGLattice &lattice, const CSGUniverse &universe, std::pair< int, int > index)
set location in the lattice to be the provided universe
Definition CSGBase.C:619
void setLatticeOuter(const CSGLattice &lattice, const std::string &outer_name)
Set the outer fill for the lattice to the material name provided.
Definition CSGBase.C:583
void updateCellFill(const CSGCell &cell, const std::string &mat_name)
change the fill of the specified cell to a material fill
Definition CSGBase.C:410
const CSGUniverse * _root_universe
root universe for the CSGBase instance
LIBMESH_DEVICE_INLINE auto row(const TensorLike &T_in, const unsigned int i) -> std::enable_if_t< is_tensor_like_v< TensorLike >, std::conditional_t< std::is_void< ResultVector >::value, libMesh::TypeVector< typename TensorLike::value_type >, ResultVector > >

◆ 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_refsmap of universe names to universe references that will be used for replacement
baseCSGBase object that contains references that should be updated

Definition at line 918 of file CSGBase.C.

921{
922 // Update universe references of cells to those of this base
923 for (auto & [cell_name, cell_ptr] : base.getCellList().getCellListMap())
924 {
925 const auto fill_type = cell_ptr->getFillType();
926 const auto fill_name = cell_ptr->getFillName();
927 if ((fill_type == "UNIVERSE") &&
928 (identical_universe_refs.find(fill_name) != identical_universe_refs.end()))
929 {
930 const CSGUniverse * univ_ptr = &identical_universe_refs.at(fill_name).get();
931 cell_ptr->updateCellFill(univ_ptr);
932 }
933 }
934
935 // Update universe references of lattices to those of this base
936 for (auto & [lat_name, lat_ptr] : base.getLatticeList().getLatticeListMap())
937 for (auto & [univ_name, univ_ref] : identical_universe_refs)
938 {
939 // Check if universe belongs to lattice
940 if (lat_ptr->hasUniverse(univ_name))
941 {
942 // If so, replace all instances of this universe in the lattice
943 const auto univ_indices = lat_ptr->getUniverseIndices(univ_name);
944 for (const auto & index : univ_indices)
945 lat_ptr->setUniverseAtIndex(univ_ref, index);
946 }
947 // Check if universe belongs to lattice outer
948 if ((lat_ptr->getOuterType() == "UNIVERSE") &&
949 (lat_ptr->getOuterUniverse().getName() == univ_name))
950 lat_ptr->updateOuter(univ_ref);
951 }
952}

◆ resetCellFill()

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

reset the fill of the specified cell to void

Parameters
cellcell to update the fill for

Definition at line 394 of file CSGBase.C.

395{
396 // cannot update region for a cell that is actually an engineering unit
397 if (cellToEngUnit(cell))
398 mooseError("Fill cannot be reset for cell '" + cell.getName() +
399 "' because it is a CSGCellEngUnit.");
400
401 if (!checkCellInBase(cell))
402 mooseError("The fill of cell with name " + cell.getName() +
403 " that is being updated is different " +
404 "from the cell of the same name in the CSGBase instance.");
405 auto & list_cell = _cell_list.getCell(cell.getName());
406 list_cell.resetCellFill();
407}
void resetCellFill()
Reset the cell fill to void.
Definition CSGCell.C:86

◆ resetLatticeOuter()

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

reset the outer fill for the lattice to VOID

Parameters
latticelattice to update

Definition at line 608 of file CSGBase.C.

609{
610 auto name = lattice.getName();
611 if (!checkLatticeInBase(lattice))
612 mooseError("Cannot reset outer for lattice " + name +
613 ". Lattice is different from the lattice of the same name in the "
614 "CSGBase instance.");
616}
void resetOuter()
reset the outer fill around the lattice elements to be VOID
Definition CSGLattice.C:143

◆ 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
latticelattice to update
outer_univuniverse to use as outer fill between lattice elements

Definition at line 594 of file CSGBase.C.

595{
596 auto name = lattice.getName();
597 if (!checkLatticeInBase(lattice))
598 mooseError("Cannot set outer universe for lattice " + name +
599 ". Lattice is different from the lattice of the same name in the "
600 "CSGBase instance.");
601 if (!checkUniverseInBase(outer_univ))
602 mooseError("Cannot set outer universe for lattice " + name + ". Outer universe " +
603 outer_univ.getName() + " is not in the CSGBase instance.");
604 _lattice_list.getLattice(name).updateOuter(outer_univ);
605}
void updateOuter(const std::string &outer_name)
Update the outer of the lattice to be the provided material name.
Definition CSGLattice.C:135

◆ 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
latticelattice to update
outer_namename of material to use as outer fill between lattice elements

Definition at line 583 of file CSGBase.C.

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

◆ 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
latticelattice to add universes to
universeslist of list of universes in the proper layout for the lattice type and dimensions

Definition at line 635 of file CSGBase.C.

638{
639 auto name = lattice.getName();
640 if (!checkLatticeInBase(lattice))
641 mooseError("Cannot set universes for lattice " + name +
642 ". Lattice is different from the lattice of the same name in the "
643 "CSGBase instance.");
644 // make sure all universes are a part of this base instance
645 for (auto univ_list : universes)
646 for (const CSGUniverse & univ : univ_list)
647 if (!checkUniverseInBase(univ))
648 mooseError("Cannot set universes for lattice " + name + ". Universe " + univ.getName() +
649 " is not in the CSGBase instance.");
650 _lattice_list.getLattice(name).setUniverses(universes);
651}
virtual void setUniverses(std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > universes)=0
assign the vectors of universes as the lattice elements

◆ 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
latticelattice to update
universeuniverse to set at the location
indexindex of the lattice element (int, int)

Definition at line 619 of file CSGBase.C.

622{
623 auto name = lattice.getName();
624 if (!checkLatticeInBase(lattice))
625 mooseError("Cannot set universe at index for lattice " + name +
626 ". Lattice is different from the lattice of the same name in the "
627 "CSGBase instance.");
628 if (!checkUniverseInBase(universe))
629 mooseError("Cannot add universe " + universe.getName() + " to lattice " + lattice.getName() +
630 ". Universe is not in the CSGBase instance.");
631 _lattice_list.getLattice(name).setUniverseAtIndex(universe, index);
632}
void setUniverseAtIndex(const CSGUniverse &universe, const std::pair< int, int > index)
replace the element at specified index in the lattice with the provided CSGUniverse.
Definition CSGLattice.C:28

◆ 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
surfCSGSurface to check/get as an engineering unit
Returns
const CSGSurfaceEngUnit* or nullptr

Definition at line 1219 of file CSGBase.h.

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

◆ 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
univCSGUniverse to check/get as an engineering unit
Returns
const CSGUniverseEngUnit* or nullptr

Definition at line 1243 of file CSGBase.h.

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

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
cellcell to update the fill for
latticepointer to lattice fill

Definition at line 447 of file CSGBase.C.

448{
449 // cannot update region for a cell that is actually an engineering unit
450 if (cellToEngUnit(cell))
451 mooseError("Fill cannot be updated for cell '" + cell.getName() +
452 "' because it is a CSGCellEngUnit.");
453
454 if (!checkLatticeInBase(*lattice))
455 mooseError("Lattice with name ",
456 lattice->getName(),
457 " is being used as a cell fill that is different from the lattice of the same name "
458 "in the CSGBase instance.");
459 if (!checkCellInBase(cell))
460 mooseError("The fill of cell with name " + cell.getName() +
461 " that is being updated is different " +
462 "from the cell of the same name in the CSGBase instance.");
463 auto & list_cell = _cell_list.getCell(cell.getName());
464 list_cell.updateCellFill(lattice);
465}
void updateCellFill(const std::string &mat_name)
Set the cell fill to a material name.
Definition CSGCell.C:95

◆ 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
cellcell to update the fill for
univpointer to universe fill

Definition at line 426 of file CSGBase.C.

427{
428 // cannot update region for a cell that is actually an engineering unit
429 if (cellToEngUnit(cell))
430 mooseError("Fill cannot be updated for cell '" + cell.getName() +
431 "' because it is a CSGCellEngUnit.");
432
433 if (!checkUniverseInBase(*univ))
434 mooseError("Universe with name ",
435 univ->getName(),
436 " is being used as a cell fill that is different from the universe of the same name "
437 "in the CSGBase instance.");
438 if (!checkCellInBase(cell))
439 mooseError("The fill of cell with name " + cell.getName() +
440 " that is being updated is different " +
441 "from the cell of the same name in the CSGBase instance.");
442 auto & list_cell = _cell_list.getCell(cell.getName());
443 list_cell.updateCellFill(univ);
444}

◆ 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
cellcell to update the fill for
mat_namename of material fill

Definition at line 410 of file CSGBase.C.

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

◆ updateCellRegion()

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

change the region of the specified cell

Parameters
cellcell to update the region for
regionnew region to assign to cell

Definition at line 377 of file CSGBase.C.

378{
379 // cannot update region for a cell that is actually an engineering unit
380 if (cellToEngUnit(cell))
381 mooseError("Region cannot be updated for cell '" + cell.getName() +
382 "' because it is a CSGCellEngUnit.");
383
384 checkRegionSurfaces(region);
385 if (!checkCellInBase(cell))
386 mooseError("The region of cell with name " + cell.getName() +
387 " that is being updated is different " +
388 "from the cell of the same name in the CSGBase instance.");
389 auto & list_cell = _cell_list.getCell(cell.getName());
390 list_cell.updateRegion(region);
391}
void updateRegion(const CSGRegion &region)
Definition CSGCell.h:151

◆ 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_baseCSGBase object that contains references that should be updated

Definition at line 843 of file CSGBase.C.

844{
845 // Iterate through all incoming surfaces and track which ones have names already
846 // defined within this CSGSurfaceList object
847 std::map<std::string, std::reference_wrapper<const CSGSurface>> identical_surface_refs;
848 auto & surf_list_map = incoming_base.getSurfaceList().getSurfaceListMap();
849 for (const auto & [surf_name, surf_ptr] : surf_list_map)
850 if (hasSurface(surf_name))
851 identical_surface_refs.insert({surf_name, getSurfaceByName(surf_name)});
852
853 // Iterate through all incoming cells and track which ones have names already
854 // defined within this CSGCellList object
855 std::map<std::string, std::reference_wrapper<const CSGCell>> identical_cell_refs;
856 auto & cell_list_map = incoming_base.getCellList().getCellListMap();
857 for (const auto & [cell_name, cell_ptr] : cell_list_map)
858 if (hasCell(cell_name))
859 identical_cell_refs.insert({cell_name, getCellByName(cell_name)});
860
861 // Iterate through all incoming universes and track which ones have names already
862 // defined within this CSGUniverseList object
863 std::map<std::string, std::reference_wrapper<const CSGUniverse>> identical_universe_refs;
864 auto & universe_list_map = incoming_base.getUniverseList().getUniverseListMap();
865 for (const auto & [univ_name, univ_ptr] : universe_list_map)
866 if (hasUniverse(univ_name))
867 identical_universe_refs.insert({univ_name, getUniverseByName(univ_name)});
868
869 // Iterate through all incoming lattices and track which ones have names already
870 // defined within this CSGLatticeList object
871 std::map<std::string, std::reference_wrapper<const CSGLattice>> identical_lattice_refs;
872 auto & lattice_list_map = incoming_base.getLatticeList().getLatticeListMap();
873 for (const auto & [lat_name, lat_ptr] : lattice_list_map)
874 if (hasLattice(lat_name))
875 identical_lattice_refs.insert({lat_name, getLatticeByName(lat_name)});
876
877 // Update all surface, cell, universe, and lattice references of incoming base to those of this
878 // base
879 if (!identical_surface_refs.empty())
880 replaceSurfaceRefsByName(identical_surface_refs, incoming_base);
881
882 if (!identical_cell_refs.empty())
883 replaceCellRefsByName(identical_cell_refs, incoming_base);
884
885 if (!identical_universe_refs.empty())
886 replaceUniverseRefsByName(identical_universe_refs, incoming_base);
887
888 if (!identical_lattice_refs.empty())
889 replaceLatticeRefsByName(identical_lattice_refs, incoming_base);
890}
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 ...
Definition CSGBase.C:918
const CSGSurface & getSurfaceByName(const std::string &name) const
Get a Surface object by name.
Definition CSGBase.h:112
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 C...
Definition CSGBase.C:955
bool hasUniverse(const std::string &name) const
Check if a universe with given name exists in CSGBase object.
Definition CSGBase.h:387
bool hasLattice(const std::string &name) const
Check if a lattice with given name exists in CSGBase object.
Definition CSGBase.h:525
bool hasSurface(const std::string &name) const
Check if a surface with given name exists in CSGBase object.
Definition CSGBase.h:123
const LatticeType & getLatticeByName(const std::string &name)
Get a lattice object of the specified type by name.
Definition CSGBase.h:509
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 CSGC...
Definition CSGBase.C:903
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 C...
Definition CSGBase.C:893
const CSGCell & getCellByName(const std::string &name) const
Get a Cell object by name.
Definition CSGBase.h:215

Member Data Documentation

◆ _cell_list

CSGCellList CSG::CSGBase::_cell_list
private

List of cells associated with CSG object.

Definition at line 1276 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 1285 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 1282 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 1273 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 1279 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: