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...
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...
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...
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...
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...
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	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...
void	joinOtherBase (std::unique_ptr< CSGBase > base)
	Join another CSGBase object to this one. More...
void	joinOtherBase (std::unique_ptr< CSGBase > base, std::string &new_root_name_join)
	Join another CSGBase object to this one. More...
void	joinOtherBase (std::unique_ptr< CSGBase > base, 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...

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) const
	Recursive method to retrieve all universes 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...
void	joinSurfaceList (CSGSurfaceList &surf_list)
	join a separate CSGSurfaceList object to this one More...
void	joinCellList (CSGCellList &cell_list)
	join a separate CSGCellList object to this one More...
void	joinUniverseList (CSGUniverseList &univ_list)
	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 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 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	checkCellInBase (const CSGCell &cell) const
bool	checkUniverseInBase (const CSGUniverse &universe) 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...
	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...

Detailed Description

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

Definition at line 29 of file CSGBase.h.

Constructor & Destructor Documentation

CSGBase() [1/2]

CSG::CSGBase::CSGBase

(

)

Default constructor.

Definition at line 15 of file CSGBase.C.

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

CSGBase() [2/2]

CSG::CSGBase::CSGBase

(

const CSGBase &

other_base

)

Copy constructor.

Definition at line 20 of file CSGBase.C.

  : _surface_list(other_base.getSurfaceList()),
    _cell_list(CSGCellList()),
    _universe_list(CSGUniverseList())
{
  // 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);
}

~CSGBase()

CSG::CSGBase::~CSGBase

(

)

Destructor.

Definition at line 45 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 179 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 48 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);
  }
  // Otherwise if the cell has a universe fill, we need to recursively define
  // all linked universes and cells first before defining this cell
  else
  {
    const auto & univ = addUniverseToList(cell.getFillUniverse());
    return _cell_list.addUniverseCell(name, univ, region);
  }
}

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

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

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

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

Referenced by addCellToList(), 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);
}

checkCellInBase()

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

private

Definition at line 342 of file CSGBase.C.

Referenced by addCellToUniverse(), removeCellFromUniverse(), 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;
}

checkRegionSurfaces()

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

private

Definition at line 325 of file CSGBase.C.

Referenced by createCell(), and updateCellRegion().

{
  auto & surfs = region.getSurfaces();
  for (const CSGSurface & s : surfs)
  {
    auto sname = s.getName();
    // if there is no surface by this name at all, there will be an error from getSurface
    const auto & list_surf = _surface_list.getSurface(s.getName());
    // if there is a surface by the same name, check that it is actually the surface being used
    // (ie same surface points to same location in memory)
    if (&s != &list_surf)
      mooseError("Region is being set with a surface named " + sname +
                 " that is different from the surface of the same name in the CSGBase instance.");
  }
}

checkUniverseInBase()

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

private

Definition at line 352 of file CSGBase.C.

Referenced by addCellToUniverse(), and removeCellFromUniverse().

{
  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 cell in the list is the same as the cell 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 362 of file CSGBase.C.

Referenced by generateOutput().

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

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

  // Iterate through all universes in universe list and check that they exist in universes linked
  // to root universe list
  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.");
}

clone()

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

inline

Create a deep copy of this CSGBase instance.

Definition at line 48 of file CSGBase.h.

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

createCell() [1/3]

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 93 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/3]

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 108 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/3]

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

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

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

Definition at line 389 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;
  }

  // Print out cell information
  auto all_cells = getAllCells();
  for (const CSGCell & c : all_cells)
  {
    const auto & cell_name = c.getName();
    const auto & cell_region = c.getRegionAsString();
    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"] = cell_region;
    csg_json["cells"][cell_name]["fill"] = fill_name;
  }

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

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

Referenced by generateOutput().

  {
    return _cell_list.getAllCells();
  }

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 67 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 262 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 153 of file CSGBase.h.

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

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

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

{ return _cell_list; }

getLinkedUniverses()

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

private

Recursive method to retrieve all universes linked to current universe.

Parameters

univ	Reference to universe under consideration
linked_universe_name	List of universe names linked to current universe

Definition at line 378 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)
    if (cell.getFillType() == "UNIVERSE")
      getLinkedUniverses(cell.getFillUniverse(), linked_universe_names);
}

getRootUniverse()

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

inline

Get the Root Universe object.

Returns

reference to root CSGUniverse

Definition at line 179 of file CSGBase.h.

Referenced by checkUniverseLinking(), createCell(), CSGBase(), 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 337 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 78 of file CSGBase.h.

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

Referenced by operator==().

{ 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 363 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 273 of file CSGBase.h.

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

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

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

{ return _universe_list; }

joinCellList()

void CSG::CSGBase::joinCellList ( CSGCellList &  cell_list )

private

join a separate CSGCellList object to this one

Parameters

cell_list

CSGCellList from a separate CSGBase object

Definition at line 249 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));
}

joinOtherBase() [1/3]

void CSG::CSGBase::joinOtherBase

(

std::unique_ptr< CSGBase >

base

)

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

Definition at line 212 of file CSGBase.C.

{
  joinSurfaceList(base->getSurfaceList());
  joinCellList(base->getCellList());
  joinUniverseList(base->getUniverseList());
}

joinOtherBase() [2/3]

void CSG::CSGBase::joinOtherBase	(	std::unique_ptr< CSGBase >	base,
		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
new_root_name_join	new name for the universe generated from the incoming root universe

Definition at line 220 of file CSGBase.C.

{
  joinSurfaceList(base->getSurfaceList());
  joinCellList(base->getCellList());
  joinUniverseList(base->getUniverseList(), new_root_name_join);
}

joinOtherBase() [3/3]

void CSG::CSGBase::joinOtherBase	(	std::unique_ptr< CSGBase >	base,
		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
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 228 of file CSGBase.C.

{
  joinSurfaceList(base->getSurfaceList());
  joinCellList(base->getCellList());
  joinUniverseList(base->getUniverseList(), new_root_name_base, new_root_name_join);
}

joinSurfaceList()

void CSG::CSGBase::joinSurfaceList ( CSGSurfaceList &  surf_list )

private

join a separate CSGSurfaceList object to this one

Parameters

surf_list

CSGSurfaceList from a separate CSGBase object

Definition at line 238 of file CSGBase.C.

Referenced by joinOtherBase().

{
  // TODO: check if surface is a duplicate (by definition) and skip
  // adding if duplicate; must update references to the surface in cell
  // region definitions.
  auto & surf_list_map = surf_list.getSurfaceListMap();
  for (auto & s : surf_list_map)
    _surface_list.addSurface(std::move(s.second));
}

joinUniverseList() [1/3]

void CSG::CSGBase::joinUniverseList ( CSGUniverseList &  univ_list )

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

Definition at line 257 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));
  }
}

joinUniverseList() [2/3]

void CSG::CSGBase::joinUniverseList ( CSGUniverseList &  univ_list, 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
new_root_name_incoming	new name for the universe generated from the incoming root universe

Definition at line 277 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));
  }
}

joinUniverseList() [3/3]

void CSG::CSGBase::joinUniverseList ( CSGUniverseList &  univ_list, 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
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 297 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));
  }
}

operator!=()

bool CSG::CSGBase::operator!=

(

const CSGBase &

other

)

const

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

Definition at line 454 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 441 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();
  return (surf_list == other_surf_list) && (cell_list == other_cell_list) &&
         (univ_list == other_univ_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 187 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 204 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 161 of file CSGBase.h.

  {
    _cell_list.renameCell(cell, 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 186 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 89 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 197 of file CSGBase.h.

  {
    _universe_list.renameUniverse(universe, name);
  }

updateCellRegion()

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

change the region of the specified cell

Parameters

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

Definition at line 141 of file CSGBase.C.

{
  checkRegionSurfaces(region);
  if (!checkCellInBase(cell))
    mooseError("The region of cell with name " + cell.getName() +
               " is being updated that 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);
}

Member Data Documentation

_cell_list

CSGCellList CSG::CSGBase::_cell_list

private

List of cells associated with CSG object.

Definition at line 470 of file CSGBase.h.

Referenced by addCellToList(), checkCellInBase(), createCell(), CSGBase(), getAllCells(), getCellByName(), getCellList(), joinCellList(), renameCell(), and updateCellRegion().

_surface_list

CSGSurfaceList CSG::CSGBase::_surface_list

private

List of surfaces associated with CSG object.

Definition at line 467 of file CSGBase.h.

Referenced by addSurface(), checkRegionSurfaces(), getAllSurfaces(), getSurface(), getSurfaceByName(), getSurfaceList(), joinSurfaceList(), and renameSurface().

_universe_list

CSGUniverseList CSG::CSGBase::_universe_list

private

List of universes associated with CSG object.

Definition at line 473 of file CSGBase.h.

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

---

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

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