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. More...
	CSGBase (const CSGBase &other_base)
	Copy constructor. More...
	~CSGBase ()
	Destructor. More...
std::unique_ptr< CSGBase >	clone () const
	Create a deep copy of this CSGBase instance. More...
const CSGSurface &	addSurface (std::unique_ptr< CSGSurface > surf)
	add a unique surface pointer to this base instance More...
void	deleteSurface (const CSGSurface &surface)
	Remove a Surface object passed in by reference from the stored surface list. More...
std::vector< std::reference_wrapper< const CSGSurface > >	getAllSurfaces () const
	Get all surface objects. More...
const CSGSurface &	getSurfaceByName (const std::string &name) const
	Get a Surface object by name. More...
bool	hasSurface (const std::string &name) const
	Check if a surface with given name exists in CSGBase object. More...
void	renameSurface (const CSGSurface &surface, const std::string &name)
	rename the specified surface More...
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. More...
const CSGCell &	createCell (const std::string &name, const CSGRegion &region, const CSGUniverse *add_to_univ=nullptr)
	Create a Void Cell object. More...
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. More...
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. More...
void	deleteCell (const CSGCell &cell)
	Remove a Cell object passed in by reference from the stored cell list. More...
std::vector< std::reference_wrapper< const CSGCell > >	getAllCells () const
	Get all cell objects. More...
const CSGCell &	getCellByName (const std::string &name) const
	Get a Cell object by name. More...
bool	hasCell (const std::string &name) const
	Check if a cell with given name exists in CSGBase object. More...
void	renameCell (const CSGCell &cell, const std::string &name)
	rename the specified cell More...
void	updateCellRegion (const CSGCell &cell, const CSGRegion &region)
	change the region of the specified cell More...
void	resetCellFill (const CSGCell &cell)
	reset the fill of the specified cell to void More...
void	updateCellFill (const CSGCell &cell, const std::string &mat_name)
	change the fill of the specified cell to a material fill More...
void	updateCellFill (const CSGCell &cell, const CSGUniverse *univ)
	change the fill of the specified cell to a universe fill More...
void	updateCellFill (const CSGCell &cell, const CSGLattice *lattice)
	change the fill of the specified cell to a lattice fill More...
const CSGUniverse &	getRootUniverse () const
	Get the Root Universe object. More...
void	renameRootUniverse (const std::string &name)
	rename the root universe for this instance (default is ROOT_UNIVERSE) More...
void	renameUniverse (const CSGUniverse &universe, const std::string &name)
	rename the specified universe More...
const CSGUniverse &	createUniverse (const std::string &name)
	Create an empty Universe object. More...
const CSGUniverse &	createUniverse (const std::string &name, std::vector< std::reference_wrapper< const CSGCell >> &cells)
	Create a Universe object from list of cells. More...
void	deleteUniverse (const CSGUniverse &univ)
	Remove a Universe object passed in by reference from the stored universe list. More...
void	addCellToUniverse (const CSGUniverse &universe, const CSGCell &cell)
	Add a cell to an existing universe. More...
void	addCellsToUniverse (const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell >> &cells)
	Add a list of cells to an existing universe. More...
void	removeCellFromUniverse (const CSGUniverse &universe, const CSGCell &cell)
	Remove a cell from an existing universe. More...
void	removeCellsFromUniverse (const CSGUniverse &universe, std::vector< std::reference_wrapper< const CSGCell >> &cells)
	Remove a list of cells from an existing universe. More...
std::vector< std::reference_wrapper< const CSGUniverse > >	getAllUniverses () const
	Get all universe objects. More...
const CSGUniverse &	getUniverseByName (const std::string &name)
	Get a universe object by name. More...
bool	hasUniverse (const std::string &name) const
	Check if a universe with given name exists in CSGBase object. More...
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. More...
void	deleteLattice (const CSGLattice &lattice)
	Remove a Lattice object passed in by reference from the stored lattice list. More...
void	setUniverseAtLatticeIndex (const CSGLattice &lattice, const CSGUniverse &universe, std::pair< int, int > index)
	set location in the lattice to be the provided universe More...
void	setLatticeUniverses (const CSGLattice &lattice, std::vector< std::vector< std::reference_wrapper< const CSGUniverse >>> &universes)
	Set provided universes as the layout of the lattice. More...
void	renameLattice (const CSGLattice &lattice, const std::string &name)
	rename the lattice More...
void	setLatticeOuter (const CSGLattice &lattice, const std::string &outer_name)
	Set the outer fill for the lattice to the material name provided. More...
void	setLatticeOuter (const CSGLattice &lattice, const CSGUniverse &outer_univ)
	Set the outer fill for the lattice to the universe provided. More...
void	resetLatticeOuter (const CSGLattice &lattice)
	reset the outer fill for the lattice to VOID More...
std::vector< std::reference_wrapper< const CSGLattice > >	getAllLattices () const
	Get all lattice objects. More...
template<typename LatticeType = CSGLattice>
const LatticeType &	getLatticeByName (const std::string &name)
	Get a lattice object of the specified type by name This is a templated method with a default type of CSGLattice. More...
bool	hasLattice (const std::string &name) const
	Check if a lattice with given name exists in CSGBase object. More...
void	joinOtherBase (std::unique_ptr< CSGBase > base, const bool ignore_identical_components)
	Join another CSGBase object to this one. More...
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. More...
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. More...
nlohmann::json	generateOutput () const
	generate the JSON representation output for the CSG object More...
bool	operator== (const CSGBase &other) const
	Operator overload for checking if two CSGBase objects are equal. More...
bool	operator!= (const CSGBase &other) const
	Operator overload for checking if two CSGBase objects are not equal. More...
void	addTransformation (const CSGObjectVariant &csg_object, TransformationType type, const std::tuple< Real, Real, Real > &values)
	Apply a transformation to a CSG object. More...
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. More...
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). More...
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). More...
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. More...

Private Member Functions
CSGSurface &	getSurface (const std::string &name)
	Get a Surface object by name. More...
void	checkUniverseLinking () const
	Check universes linked to root universe match universes defined in _universe_list. More...
void	getLinkedUniverses (const CSGUniverse &univ, std::vector< std::string > &linked_universe_names, std::vector< std::string > &linked_cell_names) const
	Recursive method to retrieve all universes and cells linked to current universe. More...
const CSGSurfaceList &	getSurfaceList () const
	Get a const reference to the CSGSurfaceList object. More...
CSGSurfaceList &	getSurfaceList ()
	Get a non-const reference to the CSGSurfaceList object. More...
const CSGCellList &	getCellList () const
	Get a const reference to the CSGCellList object. More...
CSGCellList &	getCellList ()
	Get a non-const reference to the CSGCellList object. More...
const CSGUniverseList &	getUniverseList () const
	Get a const reference to the CSGUniverseList object. More...
CSGUniverseList &	getUniverseList ()
	Get a non-const reference to the CSGUniverseList object. More...
const CSGLatticeList &	getLatticeList () const
	Get a const reference to the CSGLatticeList object. More...
CSGLatticeList &	getLatticeList ()
	Get the CSGLatticeList object. More...
void	updateIncomingCSGReferences (CSGBase &incoming_base)
	update references of incoming CSGbase to point to those of existing CSGBase object. More...
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. More...
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. More...
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. More...
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. More...
void	joinSurfaceList (CSGSurfaceList &surf_list, const bool ignore_identical_surfaces)
	join a separate CSGSurfaceList object to this one More...
void	joinCellList (CSGCellList &cell_list, const bool ignore_identical_cells)
	join a separate CSGCellList object to this one More...
void	joinLatticeList (CSGLatticeList &lattice_list, const bool ignore_identical_lattices)
	join a separate CSGLatticeList object to this one More...
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 More...
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. More...
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. More...
void	checkRegionSurfaces (const CSGRegion &region) const
bool	checkSurfaceInBase (const CSGSurface &surface) const
bool	checkCellInBase (const CSGCell &cell) const
bool	checkUniverseInBase (const CSGUniverse &universe) const
bool	checkLatticeInBase (const CSGLattice &lattice) const
const CSGCell &	addCellToList (const CSGCell &cell)
	Add a new cell to the cell list based on a cell reference. More...
const CSGUniverse &	addUniverseToList (const CSGUniverse &univ)
	Add a new universe to the universe list based on a universe reference. More...
const CSGLattice &	addLatticeToList (const CSGLattice &lattice)
	Add a new lattice to the lattice list based on a lattice reference. More...
	FRIEND_TEST (CSGBaseTest, testCheckRegionSurfaces)
	Friends for unit testing. More...
	FRIEND_TEST (CSGBaseTest, testAddGetSurface)
	FRIEND_TEST (CSGBaseTest, testUniverseLinking)

Private Attributes
CSGSurfaceList	_surface_list
	List of surfaces associated with CSG object. More...
CSGCellList	_cell_list
	List of cells associated with CSG object. More...
CSGUniverseList	_universe_list
	List of universes associated with CSG object. More...
CSGLatticeList	_lattice_list
	List of lattices associated with CSG object. More...

Detailed Description

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

Definition at line 51 of file CSGBase.h.

Constructor & Destructor Documentation

CSGBase() [1/2]

CSG::CSGBase::CSGBase

(

)

Default constructor.

Definition at line 17 of file CSGBase.C.

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

CSGBase() [2/2]

CSG::CSGBase::CSGBase

(

const CSGBase &

other_base

)

Copy constructor.

Definition at line 25 of file CSGBase.C.

  : _surface_list(other_base.getSurfaceList()),
    _cell_list(CSGCellList()),
    _universe_list(CSGUniverseList()),
    _lattice_list(CSGLatticeList())
{
  // Iterate through all cell references from the other CSGBase instance and
  // create new CSGCell pointers based on these references. This is done
  // recursively to properly handle cells with universe fills
  for (const auto & [name, cell] : other_base.getCellList().getCellListMap())
    addCellToList(*cell);

  // Link all cells in other_base root universe to current root universe
  for (auto & root_cell : other_base.getRootUniverse().getAllCells())
  {
    const auto & list_cell = _cell_list.getCell(root_cell.get().getName());
    addCellToUniverse(getRootUniverse(), list_cell);
  }

  // Iterate through all universe references from the other CSGBase instance and
  // create new CSGUniverse pointers based on these references. This is done in case
  // any universe exist in the universe list that are not connected to the cell list.
  for (const auto & [name, univ] : other_base.getUniverseList().getUniverseListMap())
    addUniverseToList(*univ);

  // Iterate through all lattice references from the other CSGBase instance and
  // create new CSGLattice pointers based on these references.
  for (const auto & [name, lattice] : other_base.getLatticeList().getLatticeListMap())
    addLatticeToList(*lattice);
}

~CSGBase()

CSG::CSGBase::~CSGBase

(

)

Destructor.

Definition at line 56 of file CSGBase.C.

{}

Member Function Documentation

addCellsToUniverse()

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

Add a list of cells to an existing universe.

Parameters

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

Definition at line 441 of file CSGBase.C.

Referenced by createUniverse().

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

addCellToList()

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

private

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

This method is called by the copy constructor of CSGBase

Parameters

cell	reference to CSGCell that should be added to cell list

Definition at line 85 of file CSGBase.C.

Referenced by addUniverseToList(), and CSGBase().

{
  // If cell has already been created, we just return a reference to it
  const auto name = cell.getName();
  if (_cell_list.hasCell(name))
    return _cell_list.getCell(name);

  // Otherwise if the cell has material or void cell, we can create it directly
  const auto fill_type = cell.getFillType();
  const auto region = cell.getRegion();
  if (fill_type == "VOID")
    return _cell_list.addVoidCell(name, region);
  else if (fill_type == "CSG_MATERIAL")
  {
    const auto mat_name = cell.getFillMaterial();
    return _cell_list.addMaterialCell(name, mat_name, region);
  }
  else if (fill_type == "LATTICE")
  {
    // add lattice recursively to capture all linked universes in the lattice
    const CSGLattice & lattice = addLatticeToList(cell.getFillLattice());
    return _cell_list.addLatticeCell(name, lattice, region);
  }
  // Otherwise if the cell has a universe fill, we need to recursively define
  // all linked universes and cells first before defining this cell
  else if (fill_type == "UNIVERSE")
  {
    const auto & univ = addUniverseToList(cell.getFillUniverse());
    return _cell_list.addUniverseCell(name, univ, region);
  }
  else
    mooseError("Cell " + name + " has unrecognized fill type " + fill_type);
}

addCellToUniverse()

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

Add a cell to an existing universe.

Parameters

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

Definition at line 424 of file CSGBase.C.

Referenced by addCellsToUniverse(), createCell(), CSGBase(), and joinUniverseList().

{
  // make sure cell is a part of this CSGBase instance
  if (!checkCellInBase(cell))
    mooseError("A cell named " + cell.getName() + " is being added to universe " +
               universe.getName() +
               " that is different from the cell of the same name in the CSGBase instance.");
  // make sure universe is a part of this CSGBase instance
  if (!checkUniverseInBase(universe))
    mooseError("Cells are being added to a universe named " + universe.getName() +
               " that is different " +
               "from the universe of the same name in the CSGBase instance.");
  auto & univ = _universe_list.getUniverse(universe.getName());
  univ.addCell(cell);
}

addLattice()

template<typename LatticeType = CSGLattice>

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

inline

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

Parameters

lattice

pointer to lattice to add

Returns

reference to CSGLattice that was added

Definition at line 403 of file CSGBase.h.

Referenced by addLatticeToList().

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

    if (lattice->getOuterType() == "UNIVERSE")
    {
      const CSGUniverse & outer_univ = lattice->getOuterUniverse();
      if (!checkUniverseInBase(outer_univ))
        mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
                   ". Outer universe " + outer_univ.getName() + " is not in the CSGBase instance.");
    }
    auto & lat_ref = _lattice_list.addLattice(std::move(lattice));
    return dynamic_cast<LatticeType &>(lat_ref);
  }

addLatticeToList()

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

private

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

This method is called by the copy constructor of CSGBase

Parameters

lattice

reference to CSGLattice that should be added to universe list

Definition at line 138 of file CSGBase.C.

Referenced by addCellToList(), and CSGBase().

{
  // If lattice has already been created, we just return a reference to it
  const auto name = lattice.getName();
  if (_lattice_list.hasLattice(name))
    return _lattice_list.getLattice(name);

  // Clone the lattice (associated universes need to be transferred and set)
  auto cloned_lattice = lattice.clone();

  // If lattice has associated universes, we need to add them to this CSGBase instance as well.
  // addUniverseToList is called recursively in case associated universes have not been added to
  // the universe list yet.
  std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> current_univ_map;
  for (const auto & univ_list : lattice.getUniverses())
  {
    std::vector<std::reference_wrapper<const CSGUniverse>> current_univ_list;
    for (const auto & univ_ref : univ_list)
      current_univ_list.push_back(addUniverseToList(univ_ref.get()));
    current_univ_map.push_back(current_univ_list);
  }

  // Set universes only if lattice has universes defined
  if (current_univ_map.size() > 0)
    cloned_lattice->setUniverses(current_univ_map);

  // Update reference to outer universe if it exists
  if (lattice.getOuterType() == "UNIVERSE")
  {
    const auto & outer_univ_ref = addUniverseToList(lattice.getOuterUniverse());
    cloned_lattice->updateOuter(outer_univ_ref);
  }

  // Use addLattice to add the cloned lattice
  return addLattice(std::move(cloned_lattice));
}

addSurface()

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

inline

add a unique surface pointer to this base instance

Parameters

surf	pointer to surface to add

Returns

reference to CSGSurface that was added

Definition at line 79 of file CSGBase.h.

  {
    return _surface_list.addSurface(std::move(surf));
  }

addTransformation()

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

Apply a transformation to a CSG object.

Parameters

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

Definition at line 545 of file CSGBase.C.

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

{
  // Use std::visit to handle each type in the variant
  std::visit(
      [&](const auto & obj)
      {
        using T = std::decay_t<decltype(obj.get())>;

        // Handle each CSG object type differently because each needs to check that it exists in
        // this base instance
        if constexpr (std::is_same_v<T, CSGCell>)
        {
          const CSGCell & cell = obj.get();
          if (!checkCellInBase(cell))
            mooseError("Cannot apply transformation to cell ",
                       cell.getName(),
                       " that is not in this CSGBase instance.");

          // Get non-const reference and apply transformation
          CSGCell & mutable_cell = _cell_list.getCell(cell.getName());
          mooseAssert(mutable_cell == cell, "Mutable cell does not match const cell passed in.");
          mutable_cell.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGSurface>)
        {
          const CSGSurface & surface = obj.get();
          if (!checkSurfaceInBase(surface))
            mooseError("Cannot apply transformation to surface ",
                       surface.getName(),
                       " that is not in this CSGBase instance.");

          // Get non-const reference and apply transformation
          CSGSurface & mutable_surface = _surface_list.getSurface(surface.getName());
          mooseAssert(mutable_surface == surface,
                      "Mutable surface does not match const surface passed in.");
          mutable_surface.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGUniverse>)
        {
          const CSGUniverse & universe = obj.get();
          if (!checkUniverseInBase(universe))
            mooseError("Cannot apply transformation to universe ",
                       universe.getName(),
                       " that is not in this CSGBase instance.");

          // Get non-const reference and apply transformation
          CSGUniverse & mutable_universe = _universe_list.getUniverse(universe.getName());
          mooseAssert(mutable_universe == universe,
                      "Mutable universe does not match const universe passed in.");
          mutable_universe.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGLattice>)
        {
          const CSGLattice & lattice = obj.get();
          if (!checkLatticeInBase(lattice))
            mooseError("Cannot apply transformation to lattice ",
                       lattice.getName(),
                       " that is not in this CSGBase instance.");

          // Get non-const reference and apply transformation
          CSGLattice & mutable_lattice = _lattice_list.getLattice(lattice.getName());
          mooseAssert(mutable_lattice == lattice,
                      "Mutable lattice does not match const lattice passed in.");
          mutable_lattice.addTransformation(type, values);
        }
        else if constexpr (std::is_same_v<T, CSGRegion>)
        {
          // iterate on the surfaces of the region and apply the transformation to those surfaces
          const CSGRegion & region = obj.get();
          const auto surfaces = region.getSurfaces();
          for (const CSGSurface & surface : surfaces)
          {
            if (!checkSurfaceInBase(surface))
              mooseError("Cannot apply transformation to region with surface ",
                         surface.getName(),
                         " that is not in this CSGBase instance.");
            addTransformation(surface, type, values);
          }
        }
        else
          mooseError("Transformation not implemented for this object type: ", typeid(T).name());
      },
      csg_object);
}

addUniverseToList()

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

private

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

This method is called by the copy constructor of CSGBase

Parameters

univ	reference to CSGUniverse that should be added to universe list

Definition at line 120 of file CSGBase.C.

Referenced by addCellToList(), addLatticeToList(), and CSGBase().

{
  // If universe has already been created, we just return a reference to it
  const auto name = univ.getName();
  if (_universe_list.hasUniverse(name))
    return _universe_list.getUniverse(name);

  // Otherwise we create a new universe based on its associated cells.
  // addCellToList is called recursively in case associated cells have not
  // been added to the cell list yet.
  const auto univ_cells = univ.getAllCells();
  std::vector<std::reference_wrapper<const CSGCell>> current_univ_cells;
  for (const auto & univ_cell : univ_cells)
    current_univ_cells.push_back(addCellToList(univ_cell));
  return createUniverse(name, current_univ_cells);
}

applyAxisRotation()

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

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

Parameters

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

Definition at line 633 of file CSGBase.C.

{
  // convert to the Euler angles (phi, theta, psi) based on axis
  Real phi = 0.0;
  Real theta = 0.0;
  Real psi = 0.0;

  switch (axis)
  {
    case RotationAxisType::X:
      theta = angle;
      break;
    case RotationAxisType::Y:
      phi = 90.0;
      theta = angle;
      psi = -90.0;
      break;
    case RotationAxisType::Z:
      phi = angle;
      break;
    default:
      mooseError("Invalid axis type provided for axis rotation.");
  }

  addTransformation(csg_object, TransformationType::ROTATION, std::make_tuple(phi, theta, psi));
}

applyRotation()

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

inline

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

Parameters

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

Definition at line 619 of file CSGBase.h.

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

applyScaling()

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

inline

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

Parameters

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

Definition at line 641 of file CSGBase.h.

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

applyTranslation()

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

inline

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

Parameters

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

Definition at line 607 of file CSGBase.h.

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

checkCellInBase()

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

private

Definition at line 956 of file CSGBase.C.

Referenced by addCellToUniverse(), addTransformation(), deleteCell(), removeCellFromUniverse(), resetCellFill(), updateCellFill(), and updateCellRegion().

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

checkLatticeInBase()

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

private

Definition at line 976 of file CSGBase.C.

Referenced by addTransformation(), deleteLattice(), resetLatticeOuter(), setLatticeOuter(), setLatticeUniverses(), setUniverseAtLatticeIndex(), and updateCellFill().

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

checkRegionSurfaces()

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

private

Definition at line 934 of file CSGBase.C.

Referenced by createCell(), and updateCellRegion().

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

checkSurfaceInBase()

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

private

Definition at line 946 of file CSGBase.C.

Referenced by addTransformation(), checkRegionSurfaces(), and deleteSurface().

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

checkUniverseInBase()

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

private

Definition at line 966 of file CSGBase.C.

Referenced by addCellToUniverse(), addLattice(), addTransformation(), deleteUniverse(), removeCellFromUniverse(), setLatticeOuter(), setLatticeUniverses(), setUniverseAtLatticeIndex(), and updateCellFill().

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

checkUniverseLinking()

void CSG::CSGBase::checkUniverseLinking ( ) const

private

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

Definition at line 986 of file CSGBase.C.

Referenced by generateOutput().

{
  std::vector<std::string> linked_universe_names;
  std::vector<std::string> linked_cell_names;

  // Recursively figure out which universe names are linked to root universe
  getLinkedUniverses(getRootUniverse(), linked_universe_names, linked_cell_names);

  // Iterate through all universes in universe list and check that they exist in universes linked
  // to root universe
  for (const CSGUniverse & univ : getAllUniverses())
    if (std::find(linked_universe_names.begin(), linked_universe_names.end(), univ.getName()) ==
        linked_universe_names.end())
      mooseWarning("Universe with name ", univ.getName(), " is not linked to root universe.");

  // Iterate through all cells in cell list and check that they exist in cells linked
  // to root universe
  for (const CSGCell & cell : getAllCells())
    if (std::find(linked_cell_names.begin(), linked_cell_names.end(), cell.getName()) ==
        linked_cell_names.end())
      mooseWarning("Cell with name ", cell.getName(), " is not linked to root universe.");
}

clone()

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

inline

Create a deep copy of this CSGBase instance.

Definition at line 70 of file CSGBase.h.

{ return std::make_unique<CSGBase>(*this); }

createCell() [1/4]

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

Create a Material Cell object.

Parameters

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

Returns

reference to CSGCell that is created

Definition at line 199 of file CSGBase.C.

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

createCell() [2/4]

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

Create a Void Cell object.

Parameters

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

Returns

reference to CSGCell that is created

Definition at line 214 of file CSGBase.C.

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

createCell() [3/4]

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

Create a Universe Cell object.

Parameters

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

Returns

reference to cell that is created

Definition at line 228 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  if (add_to_univ && (&fill_univ == add_to_univ))
    mooseError("Cell " + name +
               " cannot be filled with the same universe to which it is being added.");

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

createCell() [4/4]

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

Create a Lattice Cell object.

Parameters

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

Returns

reference to cell that is created

Definition at line 247 of file CSGBase.C.

{
  checkRegionSurfaces(region);

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

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

createUniverse() [1/2]

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

inline

Create an empty Universe object.

Parameters

name	unique universe name

Returns

reference to CSGUniverse that is created

Definition at line 308 of file CSGBase.h.

Referenced by addUniverseToList(), and joinUniverseList().

  {
    return _universe_list.addUniverse(name);
  }

createUniverse() [2/2]

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

Create a Universe object from list of cells.

Parameters

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

Returns

reference to CSGUniverse that is created

Definition at line 371 of file CSGBase.C.

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

deleteCell()

void CSG::CSGBase::deleteCell

(

const CSGCell &

cell

)

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

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

Parameters

cell	reference to cell to delete

Definition at line 275 of file CSGBase.C.

{
  if (!checkCellInBase(cell))
    mooseError("Cell with name ",
               cell.getName(),
               " cannot be deleted as it is different from the cell of the same name in the "
               "CSGBase instance.");

  // Check if cell exists in any existing universes. Cell will be removed from these universes
  for (const auto & univ_ref : _universe_list.getAllUniverses())
  {
    const auto & univ = univ_ref.get();
    const auto & univ_cells = univ.getAllCells();
    for (const auto & univ_cell : univ_cells)
      if (cell == univ_cell.get() && univ != getRootUniverse())
      {
        mooseWarning("Removing cell ",
                     cell.getName(),
                     " from universe with name ",
                     univ.getName(),
                     " before cell deletion.");
        auto & univ_to_modify = _universe_list.getUniverse(univ.getName());
        univ_to_modify.removeCell(cell.getName());
      }
  }

  _cell_list.getCellListMap().erase(cell.getName());
}

deleteLattice()

void CSG::CSGBase::deleteLattice

(

const CSGLattice &

lattice

)

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

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

Parameters

lattice

reference to lattice to delete

Definition at line 176 of file CSGBase.C.

{
  if (!checkLatticeInBase(lattice))
    mooseError("Lattice with name ",
               lattice.getName(),
               " cannot be deleted as it is different from the lattice of the same name in the "
               "CSGBase instance.");

  // Check if lattice is used as fill in existing cells
  for (const auto & cell_ref : _cell_list.getAllCells())
  {
    const auto & cell = cell_ref.get();
    if ((cell.getFillType() == "LATTICE") && (cell.getFillLattice() == lattice))
      mooseError("Cannot delete lattice with name ",
                 lattice.getName(),
                 " as it is used as the fill of cell with name ",
                 cell.getName());
  }

  _lattice_list.getLatticeListMap().erase(lattice.getName());
}

deleteSurface()

void CSG::CSGBase::deleteSurface

(

const CSGSurface &

surface

)

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

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

Parameters

surface

reference to surface to delete

Definition at line 59 of file CSGBase.C.

{
  if (!checkSurfaceInBase(surface))
    mooseError("Surface with name ",
               surface.getName(),
               " cannot be deleted as it is different from the surface of the same name in the "
               "CSGBase instance.");

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

  _surface_list.getSurfaceListMap().erase(surface.getName());
}

deleteUniverse()

void CSG::CSGBase::deleteUniverse

(

const CSGUniverse &

univ

)

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

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

Parameters

univ	reference to universe to delete

Definition at line 380 of file CSGBase.C.

{
  if (!checkUniverseInBase(univ))
    mooseError("Universe with name ",
               univ.getName(),
               " cannot be deleted as it is different from the universe of the same name in the "
               "CSGBase instance.");

  // Check if universe is the root universe
  if (univ == getRootUniverse())
    mooseError("Cannot delete root universe from CSGBase instance");

  // Check if universe is used in any existing lattices
  for (const auto & lat : _lattice_list.getAllLattices())
  {
    const auto & lattice_univs = lat.get().getUniqueUniverses();
    for (const auto & lat_univ : lattice_univs)
      if (univ == lat_univ.get())
        mooseError("Cannot delete universe with name ",
                   univ.getName(),
                   " as it is used in lattice with name ",
                   lat.get().getName());
    if ((lat.get().getOuterType() == "UNIVERSE") && (lat.get().getOuterUniverse() == univ))
      mooseError("Cannot delete universe with name ",
                 univ.getName(),
                 " as it is used as the outer universe of lattice with name ",
                 lat.get().getName());
  }

  // Check if universe is used as fill in existing cells
  for (const auto & cell_ref : _cell_list.getAllCells())
  {
    const auto & cell = cell_ref.get();
    if ((cell.getFillType() == "UNIVERSE") && (cell.getFillUniverse() == univ))
      mooseError("Cannot delete universe with name ",
                 univ.getName(),
                 " as it is used as the fill of cell with name ",
                 cell.getName());
  }

  _universe_list.getUniverseListMap().erase(univ.getName());
}

FRIEND_TEST() [1/3]

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

private

Friends for unit testing.

FRIEND_TEST() [2/3]

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

private

FRIEND_TEST() [3/3]

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

{
  // Check that orphaned universes do not exist in universe list of CSGBase object
  checkUniverseLinking();

  nlohmann::json csg_json;

  csg_json["surfaces"] = {};
  csg_json["cells"] = {};
  csg_json["universes"] = {};

  // get all surfaces information
  auto all_surfs = getAllSurfaces();
  for (const CSGSurface & s : all_surfs)
  {
    const auto & surf_name = s.getName();
    const auto & coeffs = s.getCoeffs();
    csg_json["surfaces"][surf_name] = {{"type", s.getSurfaceType()}, {"coefficients", {}}};
    for (const auto & c : coeffs)
      csg_json["surfaces"][surf_name]["coefficients"][c.first] = c.second;
    // include any information about transformations if present
    if (s.getTransformations().size() > 0)
      csg_json["surfaces"][surf_name]["transformations"] = s.getTransformationsAsStrings();
  }

  // Print out cell information
  auto all_cells = getAllCells();
  for (const CSGCell & c : all_cells)
  {
    const auto & cell_name = c.getName();
    const auto & cell_region_infix = c.getRegion().toInfixJSON();
    const auto & cell_region_postfix = c.getRegion().toPostfixStringList();
    const auto & cell_filltype = c.getFillType();
    const auto & fill_name = c.getFillName();
    csg_json["cells"][cell_name]["filltype"] = cell_filltype;
    csg_json["cells"][cell_name]["region_infix"] = cell_region_infix;
    csg_json["cells"][cell_name]["region_postfix"] = cell_region_postfix;
    csg_json["cells"][cell_name]["fill"] = fill_name;
    // include any information about transformations if present
    if (c.getTransformations().size())
      csg_json["cells"][cell_name]["transformations"] = c.getTransformationsAsStrings();
  }

  // Print out universe information
  auto all_univs = getAllUniverses();
  for (const CSGUniverse & u : all_univs)
  {
    const auto & univ_name = u.getName();
    const auto & univ_cells = u.getAllCells();
    csg_json["universes"][univ_name]["cells"] = {};
    for (const CSGCell & c : univ_cells)
      csg_json["universes"][univ_name]["cells"].push_back(c.getName());
    if (u.isRoot())
      csg_json["universes"][univ_name]["root"] = u.isRoot();
    // include any information about transformations if present
    if (u.getTransformations().size())
      csg_json["universes"][univ_name]["transformations"] = u.getTransformationsAsStrings();
  }

  // print out lattice information if lattices exist
  auto all_lats = getAllLattices();
  if (all_lats.size())
  {
    csg_json["lattices"] = {};
    for (const CSGLattice & lat : all_lats)
    {
      const auto & lat_name = lat.getName();
      csg_json["lattices"][lat_name] = {};
      csg_json["lattices"][lat_name]["type"] = lat.getType();
      const auto & outer_type = lat.getOuterType();
      csg_json["lattices"][lat_name]["outertype"] = outer_type;
      if (outer_type == "UNIVERSE")
        csg_json["lattices"][lat_name]["outer"] = lat.getOuterUniverse().getName();
      else if (outer_type == "CSG_MATERIAL")
        csg_json["lattices"][lat_name]["outer"] = lat.getOuterMaterial();
      // write out any additional attributes
      csg_json["lattices"][lat_name]["attributes"] = {};
      const auto & lat_attrs = lat.getAttributes();
      for (const auto & attr : lat_attrs)
        csg_json["lattices"][lat_name]["attributes"][attr.first] = attr.second;
      // write the map of universe names: list of lists
      csg_json["lattices"][lat_name]["universes"] = lat.getUniverseNameMap();
      // include any information about transformations if present
      if (lat.getTransformations().size())
        csg_json["lattices"][lat_name]["transformations"] = lat.getTransformationsAsStrings();
    }
  }

  return csg_json;
}

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 203 of file CSGBase.h.

Referenced by checkUniverseLinking(), and generateOutput().

  {
    return _cell_list.getAllCells();
  }

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 496 of file CSGBase.h.

Referenced by generateOutput().

  {
    return _lattice_list.getAllLattices();
  }

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 97 of file CSGBase.h.

Referenced by generateOutput().

  {
    return _surface_list.getAllSurfaces();
  }

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 370 of file CSGBase.h.

Referenced by checkUniverseLinking(), and generateOutput().

  {
    return _universe_list.getAllUniverses();
  }

getCellByName()

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

inline

Get a Cell object by name.

Parameters

name

cell name

Returns

reference to CSGCell object

Definition at line 214 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

{ return _cell_list.getCell(name); }

getCellList() [1/2]

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

inlineprivate

Get a const reference to the CSGCellList object.

Returns

CSGCellList

Definition at line 692 of file CSGBase.h.

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

{ return _cell_list; }

getCellList() [2/2]

CSGCellList& CSG::CSGBase::getCellList ( )

inlineprivate

Get a non-const reference to the CSGCellList object.

Returns

CSGCellList

Definition at line 699 of file CSGBase.h.

{ return _cell_list; }

getLatticeByName()

template<typename LatticeType = CSGLattice>

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

inline

Get a lattice object of the specified type by name This is a templated method with a default type of CSGLattice.

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

Parameters

name	lattice name

Returns

reference to CSGLattice object

Definition at line 513 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

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

getLatticeList() [1/2]

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

inlineprivate

Get a const reference to the CSGLatticeList object.

Returns

CSGLatticeList

Definition at line 720 of file CSGBase.h.

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

{ return _lattice_list; }

getLatticeList() [2/2]

CSGLatticeList& CSG::CSGBase::getLatticeList ( )

inlineprivate

Get the CSGLatticeList object.

Returns

CSGLatticeList

Definition at line 727 of file CSGBase.h.

{ return _lattice_list; }

getLinkedUniverses()

void CSG::CSGBase::getLinkedUniverses ( const CSGUniverse &  univ, std::vector< std::string > &  linked_universe_names, std::vector< std::string > &  linked_cell_names  ) const

private

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

Parameters

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

Definition at line 1010 of file CSGBase.C.

Referenced by checkUniverseLinking().

{
  linked_universe_names.push_back(univ.getName());
  const auto & univ_cells = univ.getAllCells();
  for (const CSGCell & cell : univ_cells)
  {
    linked_cell_names.push_back(cell.getName());
    if (cell.getFillType() == "UNIVERSE")
      getLinkedUniverses(cell.getFillUniverse(), linked_universe_names, linked_cell_names);
    else if (cell.getFillType() == "LATTICE")
    {
      const auto & lattice = cell.getFillLattice();
      for (const auto & univ_list : lattice.getUniverses())
        for (const auto & univ_ref : univ_list)
        {
          const CSGUniverse & lattice_univ = univ_ref.get();
          getLinkedUniverses(lattice_univ, linked_universe_names, linked_cell_names);
        }

      if (lattice.getOuterType() == "UNIVERSE")
      {
        const CSGUniverse & outer_univ = lattice.getOuterUniverse();
        getLinkedUniverses(outer_univ, linked_universe_names, linked_cell_names);
      }
    }
  }
}

getRootUniverse()

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

inline

Get the Root Universe object.

Returns

reference to root CSGUniverse

Definition at line 279 of file CSGBase.h.

Referenced by checkUniverseLinking(), createCell(), CSGBase(), deleteCell(), deleteUniverse(), and joinUniverseList().

{ return _universe_list.getRoot(); }

getSurface()

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

inlineprivate

Get a Surface object by name.

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

Parameters

name	surface name

Returns

reference to CSGSurface object

Definition at line 657 of file CSGBase.h.

{ return _surface_list.getSurface(name); }

getSurfaceByName()

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

inline

Get a Surface object by name.

Parameters

name	surface name

Returns

reference to CSGSurface object

Definition at line 108 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

  {
    return _surface_list.getSurface(name);
  }

getSurfaceList() [1/2]

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

inlineprivate

Get a const reference to the CSGSurfaceList object.

Returns

CSGSurfaceList

Definition at line 678 of file CSGBase.h.

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

{ return _surface_list; }

getSurfaceList() [2/2]

CSGSurfaceList& CSG::CSGBase::getSurfaceList ( )

inlineprivate

Get a non-const reference to the CSGSurfaceList object.

Returns

CSGSurfaceList

Definition at line 685 of file CSGBase.h.

{ return _surface_list; }

getUniverseByName()

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

inline

Get a universe object by name.

Parameters

name	universe name

Returns

reference to CSGUniverse object

Definition at line 381 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

  {
    return _universe_list.getUniverse(name);
  }

getUniverseList() [1/2]

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

inlineprivate

Get a const reference to the CSGUniverseList object.

Returns

CSGUniverseList

Definition at line 706 of file CSGBase.h.

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

{ return _universe_list; }

getUniverseList() [2/2]

CSGUniverseList& CSG::CSGBase::getUniverseList ( )

inlineprivate

Get a non-const reference to the CSGUniverseList object.

Returns

CSGUniverseList

Definition at line 713 of file CSGBase.h.

{ return _universe_list; }

hasCell()

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

inline

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

Parameters

name

cell name

Returns

true if cell with given name exists in CSGBase

Definition at line 222 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

{ return _cell_list.hasCell(name); }

hasLattice()

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

inline

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

Parameters

name	lattice name

Returns

true if lattice with given name exists in CSGBase

Definition at line 529 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

{ return _lattice_list.hasLattice(name); }

hasSurface()

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

inline

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

Parameters

name	surface name

Returns

true if surface with given name exists in CSGBase

Definition at line 119 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

{ return _surface_list.hasSurface(name); }

hasUniverse()

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

inline

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

Parameters

name	universe name

Returns

true if universe with given name exists in CSGBase

Definition at line 392 of file CSGBase.h.

Referenced by updateIncomingCSGReferences().

{ return _universe_list.hasUniverse(name); }

joinCellList()

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

private

join a separate CSGCellList object to this one

Parameters

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

Definition at line 847 of file CSGBase.C.

Referenced by joinOtherBase().

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

joinLatticeList()

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

private

join a separate CSGLatticeList object to this one

Parameters

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

Definition at line 855 of file CSGBase.C.

Referenced by joinOtherBase().

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

joinOtherBase() [1/3]

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

Join another CSGBase object to this one.

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

Parameters

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

Definition at line 663 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(base->getUniverseList(), ignore_identical_components);
}

joinOtherBase() [2/3]

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

Join another CSGBase object to this one.

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

Parameters

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

Definition at line 676 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(base->getUniverseList(), ignore_identical_components, new_root_name_join);
}

joinOtherBase() [3/3]

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

Join another CSGBase object to this one.

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

Parameters

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

Definition at line 691 of file CSGBase.C.

{
  // If we are ignoring identical incoming CSG components, we need to update any references
  // stored by these components to point to the references of the pre-existing CSGBase object
  if (ignore_identical_components)
    updateIncomingCSGReferences(*base);
  joinSurfaceList(base->getSurfaceList(), ignore_identical_components);
  joinCellList(base->getCellList(), ignore_identical_components);
  joinLatticeList(base->getLatticeList(), ignore_identical_components);
  joinUniverseList(
      base->getUniverseList(), ignore_identical_components, new_root_name_base, new_root_name_join);
}

joinSurfaceList()

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

private

join a separate CSGSurfaceList object to this one

Parameters

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

Definition at line 839 of file CSGBase.C.

Referenced by joinOtherBase().

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

joinUniverseList() [1/3]

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

private

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

Parameters

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

Definition at line 863 of file CSGBase.C.

Referenced by joinOtherBase().

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

joinUniverseList() [2/3]

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

private

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

Parameters

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

Definition at line 883 of file CSGBase.C.

{
  // case 2: incoming root is turned into new universe and existing root remains root

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

joinUniverseList() [3/3]

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

private

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

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

Parameters

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

Definition at line 905 of file CSGBase.C.

{
  // case 3: each root universe becomes a new universe and a new root is created

  // make a new universe from the existing root universe
  auto & root = getRootUniverse();
  auto root_cells = root.getAllCells();
  createUniverse(new_root_name_base, root_cells);
  removeCellsFromUniverse(root, root_cells);

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

operator!=()

bool CSG::CSGBase::operator!=

(

const CSGBase &

other

)

const

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

Definition at line 1148 of file CSGBase.C.

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

operator==()

bool CSG::CSGBase::operator==

(

const CSGBase &

other

)

const

Operator overload for checking if two CSGBase objects are equal.

Definition at line 1133 of file CSGBase.C.

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

removeCellFromUniverse()

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

Remove a cell from an existing universe.

Parameters

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

Definition at line 449 of file CSGBase.C.

Referenced by removeCellsFromUniverse().

{
  // make sure cell is a part of this CSGBase instance
  if (!checkCellInBase(cell))
    mooseError("A cell named " + cell.getName() + " is being removed from universe " +
               universe.getName() +
               " that is different from the cell of the same name in the CSGBase instance.");
  // make sure universe is a part of this CSGBase instance
  if (!checkUniverseInBase(universe))
    mooseError("Cells are being removed from a universe named " + universe.getName() +
               " that is different " +
               "from the universe of the same name in the CSGBase instance.");
  auto & univ = _universe_list.getUniverse(universe.getName());
  univ.removeCell(cell.getName());
}

removeCellsFromUniverse()

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

Remove a list of cells from an existing universe.

Parameters

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

Definition at line 466 of file CSGBase.C.

Referenced by joinUniverseList().

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

renameCell()

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

inline

rename the specified cell

Parameters

cell	reference to CSGCell to rename
name	new name

Definition at line 230 of file CSGBase.h.

  {
    _cell_list.renameCell(cell, name);
  }

renameLattice()

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

inline

rename the lattice

Parameters

lattice	lattice to rename
name	new name

Definition at line 461 of file CSGBase.h.

  {
    _lattice_list.renameLattice(lattice, name);
  }

renameRootUniverse()

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

inline

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

Parameters

name	new name for the root universe

Definition at line 286 of file CSGBase.h.

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

renameSurface()

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

inline

rename the specified surface

Parameters

surface	CSGSurface to rename
name	new name

Definition at line 127 of file CSGBase.h.

  {
    _surface_list.renameSurface(surface, name);
  }

renameUniverse()

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

inline

rename the specified universe

Parameters

universe	reference to CSGUniverse to rename
name	new name

Definition at line 297 of file CSGBase.h.

  {
    _universe_list.renameUniverse(universe, name);
  }

replaceCellRefsByName()

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

private

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

This involves updating the cell references of universes.

Parameters

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

Definition at line 768 of file CSGBase.C.

Referenced by updateIncomingCSGReferences().

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

replaceLatticeRefsByName()

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

private

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

This involves updating the lattice references of cells.

Parameters

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

Definition at line 820 of file CSGBase.C.

Referenced by updateIncomingCSGReferences().

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

replaceSurfaceRefsByName()

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

private

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

This involves updating the surface references of cell regions.

Parameters

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

Definition at line 758 of file CSGBase.C.

Referenced by updateIncomingCSGReferences().

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

replaceUniverseRefsByName()

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

private

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

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

Parameters

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

Definition at line 783 of file CSGBase.C.

Referenced by updateIncomingCSGReferences().

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

  // Update universe references of lattices to those of this base
  for (auto & [lat_name, lat_ptr] : base.getLatticeList().getLatticeListMap())
    for (auto & [univ_name, univ_ref] : identical_universe_refs)
    {
      // Check if universe belongs to lattice
      if (lat_ptr->hasUniverse(univ_name))
      {
        // If so, replace all instances of this universe in the lattice
        const auto univ_indices = lat_ptr->getUniverseIndices(univ_name);
        for (const auto & index : univ_indices)
          lat_ptr->setUniverseAtIndex(univ_ref, index);
      }
      // Check if universe belongs to lattice outer
      if ((lat_ptr->getOuterType() == "UNIVERSE") &&
          (lat_ptr->getOuterUniverse().getName() == univ_name))
        lat_ptr->updateOuter(univ_ref);
    }
}

resetCellFill()

void CSG::CSGBase::resetCellFill

(

const CSGCell &

cell

)

reset the fill of the specified cell to void

Parameters

cell	cell to update the fill for

Definition at line 317 of file CSGBase.C.

{
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.resetCellFill();
}

resetLatticeOuter()

void CSG::CSGBase::resetLatticeOuter

(

const CSGLattice &

lattice

)

reset the outer fill for the lattice to VOID

Parameters

lattice

lattice to update

Definition at line 499 of file CSGBase.C.

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

setLatticeOuter() [1/2]

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

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

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

Parameters

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

Definition at line 474 of file CSGBase.C.

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

setLatticeOuter() [2/2]

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

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

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

Parameters

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

Definition at line 485 of file CSGBase.C.

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

setLatticeUniverses()

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

Set provided universes as the layout of the lattice.

Parameters

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

Definition at line 526 of file CSGBase.C.

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

setUniverseAtLatticeIndex()

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

set location in the lattice to be the provided universe

Parameters

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

Definition at line 510 of file CSGBase.C.

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

updateCellFill() [1/3]

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

change the fill of the specified cell to a material fill

Parameters

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

Definition at line 328 of file CSGBase.C.

{
  if (!checkCellInBase(cell))
    mooseError("The region of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(mat_name);
}

updateCellFill() [2/3]

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

change the fill of the specified cell to a universe fill

Parameters

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

Definition at line 339 of file CSGBase.C.

{
  if (!checkUniverseInBase(*univ))
    mooseError("Universe with name ",
               univ->getName(),
               " is being used as a cell fill that is different from the universe of the same name "
               "in the CSGBase instance.");
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(univ);
}

updateCellFill() [3/3]

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

change the fill of the specified cell to a lattice fill

Parameters

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

Definition at line 355 of file CSGBase.C.

{
  if (!checkLatticeInBase(*lattice))
    mooseError("Lattice with name ",
               lattice->getName(),
               " is being used as a cell fill that is different from the lattice of the same name "
               "in the CSGBase instance.");
  if (!checkCellInBase(cell))
    mooseError("The fill of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateCellFill(lattice);
}

updateCellRegion()

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

change the region of the specified cell

Parameters

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

Definition at line 305 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  if (!checkCellInBase(cell))
    mooseError("The region of cell with name " + cell.getName() +
               " that is being updated is different " +
               "from the cell of the same name in the CSGBase instance.");
  auto & list_cell = _cell_list.getCell(cell.getName());
  list_cell.updateRegion(region);
}

updateIncomingCSGReferences()

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

private

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

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

Parameters

incoming_base

CSGBase object that contains references that should be updated

Definition at line 708 of file CSGBase.C.

Referenced by joinOtherBase().

{
  // Iterate through all incoming surfaces and track which ones have names already
  // defined within this CSGSurfaceList object
  std::map<std::string, std::reference_wrapper<const CSGSurface>> identical_surface_refs;
  auto & surf_list_map = incoming_base.getSurfaceList().getSurfaceListMap();
  for (const auto & [surf_name, surf_ptr] : surf_list_map)
    if (hasSurface(surf_name))
      identical_surface_refs.insert({surf_name, getSurfaceByName(surf_name)});

  // Iterate through all incoming cells and track which ones have names already
  // defined within this CSGCellList object
  std::map<std::string, std::reference_wrapper<const CSGCell>> identical_cell_refs;
  auto & cell_list_map = incoming_base.getCellList().getCellListMap();
  for (const auto & [cell_name, cell_ptr] : cell_list_map)
    if (hasCell(cell_name))
      identical_cell_refs.insert({cell_name, getCellByName(cell_name)});

  // Iterate through all incoming universes and track which ones have names already
  // defined within this CSGUniverseList object
  std::map<std::string, std::reference_wrapper<const CSGUniverse>> identical_universe_refs;
  auto & universe_list_map = incoming_base.getUniverseList().getUniverseListMap();
  for (const auto & [univ_name, univ_ptr] : universe_list_map)
    if (hasUniverse(univ_name))
      identical_universe_refs.insert({univ_name, getUniverseByName(univ_name)});

  // Iterate through all incoming lattices and track which ones have names already
  // defined within this CSGLatticeList object
  std::map<std::string, std::reference_wrapper<const CSGLattice>> identical_lattice_refs;
  auto & lattice_list_map = incoming_base.getLatticeList().getLatticeListMap();
  for (const auto & [lat_name, lat_ptr] : lattice_list_map)
    if (hasLattice(lat_name))
      identical_lattice_refs.insert({lat_name, getLatticeByName(lat_name)});

  // Update all surface, cell, universe, and lattice references of incoming base to those of this
  // base
  if (!identical_surface_refs.empty())
    replaceSurfaceRefsByName(identical_surface_refs, incoming_base);

  if (!identical_cell_refs.empty())
    replaceCellRefsByName(identical_cell_refs, incoming_base);

  if (!identical_universe_refs.empty())
    replaceUniverseRefsByName(identical_universe_refs, incoming_base);

  if (!identical_lattice_refs.empty())
    replaceLatticeRefsByName(identical_lattice_refs, incoming_base);
}

Member Data Documentation

_cell_list

CSGCellList CSG::CSGBase::_cell_list

private

List of cells associated with CSG object.

Definition at line 900 of file CSGBase.h.

Referenced by addCellToList(), addTransformation(), checkCellInBase(), createCell(), CSGBase(), deleteCell(), deleteLattice(), deleteSurface(), deleteUniverse(), getAllCells(), getCellByName(), getCellList(), hasCell(), joinCellList(), renameCell(), resetCellFill(), updateCellFill(), and updateCellRegion().

_lattice_list

CSGLatticeList CSG::CSGBase::_lattice_list

private

List of lattices associated with CSG object.

Definition at line 906 of file CSGBase.h.

Referenced by addLattice(), addLatticeToList(), addTransformation(), checkLatticeInBase(), deleteLattice(), deleteUniverse(), getAllLattices(), getLatticeByName(), getLatticeList(), hasLattice(), joinLatticeList(), renameLattice(), resetLatticeOuter(), setLatticeOuter(), setLatticeUniverses(), and setUniverseAtLatticeIndex().

_surface_list

CSGSurfaceList CSG::CSGBase::_surface_list

private

List of surfaces associated with CSG object.

Definition at line 897 of file CSGBase.h.

Referenced by addSurface(), addTransformation(), checkSurfaceInBase(), deleteSurface(), getAllSurfaces(), getSurface(), getSurfaceByName(), getSurfaceList(), hasSurface(), joinSurfaceList(), and renameSurface().

_universe_list

CSGUniverseList CSG::CSGBase::_universe_list

private

List of universes associated with CSG object.

Definition at line 903 of file CSGBase.h.

Referenced by addCellToUniverse(), addTransformation(), addUniverseToList(), checkUniverseInBase(), createUniverse(), deleteCell(), deleteUniverse(), getAllUniverses(), getRootUniverse(), getUniverseByName(), getUniverseList(), hasUniverse(), joinUniverseList(), removeCellFromUniverse(), renameRootUniverse(), and renameUniverse().

---

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

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