CSG::CSGLattice Class Reference

CSGLattice is the abstract class for defining lattices. More...

#include <CSGLattice.h>

Inheritance diagram for CSG::CSGLattice:

Public Member Functions
	CSGLattice (const std::string &name, const std::string &lattice_type, const std::optional< OuterVariant > &outer=std::nullopt)
	Construct a new CSGLattice of specific type. More...
virtual	~CSGLattice ()=default
	Destructor. More...
virtual std::unique_ptr< CSGLattice >	clone () const =0
const std::string &	getName () const
	Get the name of lattice. More...
const std::string &	getType () const
	Get the lattice type. More...
const std::string	getOuterType () const
	Get the type of outer that fills the space around the lattice elements. More...
const CSGUniverse &	getOuterUniverse () const
	Get the outer universe if outer type is UNIVERSE. More...
const std::string &	getOuterMaterial () const
	Get the outer material name if outer fype is CSG_MATERIAL. More...
std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > >	getUniverses () const
	Get the arrangement of CSGUniverses in the lattice. More...
const std::vector< std::vector< std::string > >	getUniverseNameMap () const
	Get the arrangement of CSGUniverses in the lattice as their names. More...
bool	hasUniverse (const std::string &name) const
	whether or not the universe of the specified name exists in the lattice More...
virtual std::unordered_map< std::string, AttributeVariant >	getAttributes () const =0
	Get attributes that define the lattice (excluding the universe map). More...
virtual bool	isValidIndex (const std::pair< int, int > index) const =0
	Checks if the given index location is a valid index for the lattice. More...
const CSGUniverse &	getUniverseAtIndex (const std::pair< int, int > index)
	Get the universe located at the given index. More...
const std::vector< std::pair< unsigned int, unsigned int > >	getUniverseIndices (const std::string &univ_name) const
	get all locations in lattice where universe of the specified name exists More...
virtual bool	isValidUniverseMap (std::vector< std::vector< std::reference_wrapper< const CSGUniverse >>> universes) const =0
	check that any provided list of list of CSGUniverses are the correct dimensions for the type of lattice More...
void	resetOuter ()
	reset the outer fill around the lattice elements to be VOID More...
const std::vector< std::reference_wrapper< const CSGUniverse > >	getUniqueUniverses () const
	Get the list of unique universe objects in the lattice. More...
bool	operator== (const CSGLattice &other) const
	Operator overload for checking if two CSGLattice objects are equal. More...
bool	operator!= (const CSGLattice &other) const
	Operator overload for checking if two CSGLattice objects are not equal. More...
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const
	Get the list of transformations. More...
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const
	Get the transformations of this object with string representations for types. More...

Static Public Member Functions
static bool	isValidTransformationValue (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Check if the transformation value is valid for the given type. More...
static std::string	getTransformationTypeString (TransformationType type)
	Get the string representation of the transformation type. More...

Protected Member Functions
void	setName (const std::string &name)
virtual void	setUniverses (std::vector< std::vector< std::reference_wrapper< const CSGUniverse >>> universes)=0
	assign the vectors of universes as the lattice elements More...
void	setUniverseAtIndex (const CSGUniverse &universe, const std::pair< int, int > index)
	replace the element at specified index in the lattice with the provided CSGUniverse. More...
virtual bool	compareAttributes (const CSGLattice &other) const =0
	helper function to compare the attributes of the lattice type More...
void	updateOuter (const std::string &outer_name)
	Update the outer of the lattice to be the provided material name. More...
void	updateOuter (const CSGUniverse &outer_universe)
	Update the outer of the lattice to be the provided universe. More...
void	addTransformation (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Add a transformation to the list of transformations. More...
Point	applyReverseTransformsToPoint (Point p) const
	update the value of point p by applying the inverse of the list of transformations to the point More...
	FRIEND_TEST (CSGLatticeTest, testSetName)
	Friends for unit testing. More...
	FRIEND_TEST (CSGLatticeTest, testUpdateOuter)
	FRIEND_TEST (CSGBaseTest, testAddLattice)
	FRIEND_TEST (CSGLatticeTest, testCartLatticeEquality)
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing. More...
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

Protected Attributes
std::string	_name
	Name of lattice. More...
const std::string	_lattice_type
	Type of lattice. More...
std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > >	_universe_map
	Universes in the arrangement of how they appear in the lattice; dimensions depends on lattice type. More...
std::string	_outer_type
	An enum for type of outer fill for lattice. More...
std::string	_outer_material
	name of the outer material More...
const CSGUniverse *	_outer_universe
	outer object if fill is CSGUniverse More...
std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object. More...

Friends
class	CSGLatticeList
class	CSGBase

Detailed Description

CSGLattice is the abstract class for defining lattices.

Definition at line 34 of file CSGLattice.h.

Constructor & Destructor Documentation

CSGLattice()

CSG::CSGLattice::CSGLattice	(	const std::string &	name,
		const std::string &	lattice_type,
		const std::optional< OuterVariant > &	outer = std::nullopt
	)

Construct a new CSGLattice of specific type.

Parameters

name	unique name of lattice
lattice_type	type of lattice
outer	optional outer universe or material name that fills space around lattice elements. If not provided, outer is assumed to be VOID.

Definition at line 16 of file CSGLattice.C.

  : _name(name), _lattice_type(lattice_type), _outer_type("VOID"), _outer_universe(nullptr)
{
  CSGUtils::checkValidCSGName(name);
  // Handle the outer variant if provided
  if (outer.has_value())
  {
    std::visit([this](auto && outer_arg) { updateOuter(outer_arg); }, outer.value());
  }
}

~CSGLattice()

virtual CSG::CSGLattice::~CSGLattice ( )

virtualdefault

Destructor.

Member Function Documentation

addTransformation()

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

protectedinherited

Add a transformation to the list of transformations.

Parameters

type	The type of transformation
values	The values for the transformation

Definition at line 16 of file CSGTransformationHelper.C.

{
  if (!isValidTransformationValue(type, values))
    mooseError("Invalid transformation values provided for transformation type " +
               getTransformationTypeString(type));
  _transformations.emplace_back(type, values);
}

applyReverseTransformsToPoint()

Point CSG::CSGTransformationHelper::applyReverseTransformsToPoint ( Point  p ) const

protectedinherited

update the value of point p by applying the inverse of the list of transformations to the point

Parameters

p	point to transform

Returns

transformed point

Definition at line 74 of file CSGTransformationHelper.C.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint().

{
  // iterate list of transformations in reverse and apply the inverse operation
  for (auto it = _transformations.rbegin(); it != _transformations.rend(); ++it)
  {
    auto trans_type = it->first;
    auto val = it->second;

    if (trans_type == TransformationType::TRANSLATION)
    {
      Point offset(std::get<0>(val), std::get<1>(val), std::get<2>(val));
      p -= offset;
    }
    else if (trans_type == TransformationType::SCALE)
    {
      Point scale(std::get<0>(val), std::get<1>(val), std::get<2>(val));
      for (int i = 0; i < 3; ++i)
        p(i) /= scale(i);
    }
    else if (trans_type == TransformationType::ROTATION)
    {
      // get the transpose of the original rotation matrix and apply to point p
      const auto rot_matrix = RealTensorValue::intrinsic_rotation_matrix(
          std::get<0>(val), std::get<1>(val), std::get<2>(val));
      const auto rot_transpose = rot_matrix.transpose();
      p = rot_transpose * p;
    }
    else
      mooseError("Transformation type is not recognized.");
  }
  return p;
}

clone()

virtual std::unique_ptr<CSGLattice> CSG::CSGLattice::clone ( ) const

pure virtual

Implemented in CSG::CSGHexagonalLattice, and CSG::CSGCartesianLattice.

Referenced by CSG::CSGBase::addLatticeToList().

compareAttributes()

virtual bool CSG::CSGLattice::compareAttributes ( const CSGLattice &  other ) const

protectedpure virtual

helper function to compare the attributes of the lattice type

Implemented in CSG::CSGHexagonalLattice, and CSG::CSGCartesianLattice.

Referenced by operator==().

FRIEND_TEST() [1/6]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [2/6]

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

protectedinherited

FRIEND_TEST() [3/6]

CSG::CSGLattice::FRIEND_TEST ( CSGLatticeTest  , testSetName    )

protected

Friends for unit testing.

FRIEND_TEST() [4/6]

CSG::CSGLattice::FRIEND_TEST ( CSGLatticeTest  , testUpdateOuter    )

protected

FRIEND_TEST() [5/6]

CSG::CSGLattice::FRIEND_TEST ( CSGBaseTest  , testAddLattice    )

protected

FRIEND_TEST() [6/6]

CSG::CSGLattice::FRIEND_TEST ( CSGLatticeTest  , testCartLatticeEquality    )

protected

getAttributes()

virtual std::unordered_map<std::string, AttributeVariant> CSG::CSGLattice::getAttributes ( ) const

pure virtual

Get attributes that define the lattice (excluding the universe map).

Returns

map of string attribute name to value of that attribute

Implemented in CSG::CSGHexagonalLattice, and CSG::CSGCartesianLattice.

Referenced by CSG::CSGCartesianLattice::compareAttributes(), and CSG::CSGHexagonalLattice::compareAttributes().

getName()

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

inline

Get the name of lattice.

Returns

std::string name of lattice

Definition at line 62 of file CSGLattice.h.

Referenced by CSG::CSGLatticeList::addLattice(), CSG::CSGBase::addLatticeToList(), CSG::CSGBase::addTransformation(), CSG::CSGBase::checkLatticeInBase(), CSG::CSGCartesianLattice::CSGCartesianLattice(), CSG::CSGHexagonalLattice::CSGHexagonalLattice(), CSG::CSGBase::deleteLattice(), CSG::CSGCell::getFillName(), getOuterMaterial(), getOuterUniverse(), CSG::CSGHexagonalLattice::getRingIndexFromRowIndex(), CSG::CSGHexagonalLattice::getRowIndexFromRingIndex(), getUniverseAtIndex(), getUniverseIndices(), operator==(), CSG::CSGLatticeList::renameLattice(), CSG::CSGBase::resetLatticeOuter(), CSG::CSGBase::setLatticeOuter(), CSG::CSGBase::setLatticeUniverses(), CSG::CSGCartesianLattice::setPitch(), CSG::CSGHexagonalLattice::setPitch(), setUniverseAtIndex(), CSG::CSGBase::setUniverseAtLatticeIndex(), CSG::CSGCartesianLattice::setUniverses(), CSG::CSGHexagonalLattice::setUniverses(), and CSG::CSGBase::updateCellFill().

{ return _name; }

getOuterMaterial()

const std::string & CSG::CSGLattice::getOuterMaterial

(

)

const

Get the outer material name if outer fype is CSG_MATERIAL.

Returns

name of the CSG material fill

Definition at line 120 of file CSGLattice.C.

Referenced by operator==().

{
  if (getOuterType() != "CSG_MATERIAL")
    mooseError("Lattice '" + getName() + "' has " + getOuterType() + " outer, not CSG_MATERIAL.");
  else
    return _outer_material;
}

getOuterType()

const std::string CSG::CSGLattice::getOuterType ( ) const

inline

Get the type of outer that fills the space around the lattice elements.

Returns

string of outer type: CSG_MATERIAL, UNIVERSE, or VOID

Definition at line 76 of file CSGLattice.h.

Referenced by CSG::CSGBase::addLatticeToList(), getOuterMaterial(), getOuterUniverse(), and operator==().

{ return _outer_type; }

getOuterUniverse()

const CSGUniverse & CSG::CSGLattice::getOuterUniverse

(

)

const

Get the outer universe if outer type is UNIVERSE.

Returns

Reference to CSGUniverse

Definition at line 111 of file CSGLattice.C.

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

{
  if (getOuterType() != "UNIVERSE")
    mooseError("Lattice '" + getName() + "' has " + getOuterType() + " outer, not UNIVERSE.");
  else
    return *_outer_universe;
}

getTransformations()

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

inlineinherited

Get the list of transformations.

Returns

The list of transformations

Definition at line 47 of file CSGTransformationHelper.h.

Referenced by CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGUniverse::operator==(), CSG::CSGSurface::operator==(), CSG::CSGCell::operator==(), and operator==().

  {
    return _transformations;
  }

getTransformationsAsStrings()

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

inherited

Get the transformations of this object with string representations for types.

Returns

Vector of transformation pairs with string representations for types

Definition at line 65 of file CSGTransformationHelper.C.

{
  std::vector<std::pair<std::string, std::tuple<Real, Real, Real>>> result;
  for (const auto & transform_pair : _transformations)
    result.emplace_back(getTransformationTypeString(transform_pair.first), transform_pair.second);
  return result;
}

getTransformationTypeString()

std::string CSG::CSGTransformationHelper::getTransformationTypeString ( TransformationType  type )

staticinherited

Get the string representation of the transformation type.

Parameters

type	The transformation type

Returns

String name of the transformation type

Definition at line 56 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation(), and CSG::CSGTransformationHelper::getTransformationsAsStrings().

{
  // Set the enum to the value and convert it to string
  MooseEnum enum_copy = transformation_type_enum;
  enum_copy = static_cast<int>(type);
  return std::string(enum_copy);
}

getType()

const std::string& CSG::CSGLattice::getType ( ) const

inline

Get the lattice type.

Returns

std::string type of lattice

Definition at line 69 of file CSGLattice.h.

Referenced by CSG::CSGCartesianLattice::compareAttributes(), CSG::CSGHexagonalLattice::compareAttributes(), operator==(), CSG::CSGCartesianLattice::setUniverses(), and CSG::CSGHexagonalLattice::setUniverses().

{ return _lattice_type; }

getUniqueUniverses()

const std::vector< std::reference_wrapper< const CSGUniverse > > CSG::CSGLattice::getUniqueUniverses

(

)

const

Get the list of unique universe objects in the lattice.

Returns

list of references to unique CSGUniverse objects

Definition at line 93 of file CSGLattice.C.

{
  std::vector<std::reference_wrapper<const CSGUniverse>> unique_univs;
  auto all_univs = getUniverses();

  for (const auto & ulist : all_univs)
    for (const auto & u : ulist)
    {
      auto it = std::find_if(unique_univs.begin(),
                             unique_univs.end(),
                             [&u](const auto & ref) { return &ref.get() == &u.get(); });
      if (it == unique_univs.end())
        unique_univs.push_back(u);
    }
  return unique_univs;
}

getUniverseAtIndex()

const CSGUniverse & CSG::CSGLattice::getUniverseAtIndex

(

const std::pair< int, int >

index

)

Get the universe located at the given index.

Parameters

index

pair of ints that specify the location in lattice

Returns

universe at the specified location

Definition at line 66 of file CSGLattice.C.

{
  if (!isValidIndex(index))
    mooseError("Index (" + std::to_string(index.first) + ", " + std::to_string(index.second) +
               ") is not a valid index for lattice " + getName());
  else
    return _universe_map[index.first][index.second];
}

getUniverseIndices()

const std::vector< std::pair< unsigned int, unsigned int > > CSG::CSGLattice::getUniverseIndices

(

const std::string &

univ_name

)

const

get all locations in lattice where universe of the specified name exists

Parameters

univ_name

name of universe

Returns

vector of locations (pairs of ints)

Definition at line 76 of file CSGLattice.C.

{
  if (!hasUniverse(univ_name))
    mooseError("Universe " + univ_name + " does not exist in lattice " + getName());

  std::vector<std::pair<unsigned int, unsigned int>> indices;
  for (auto i : index_range(_universe_map))
    for (auto j : index_range(_universe_map[i]))
    {
      const CSGUniverse & univ = _universe_map[i][j];
      if (univ.getName() == univ_name)
        indices.push_back(std::make_pair(i, j));
    }
  return indices;
}

getUniverseNameMap()

const std::vector< std::vector< std::string > > CSG::CSGLattice::getUniverseNameMap

(

)

const

Get the arrangement of CSGUniverses in the lattice as their names.

Returns

list of list of universe names

Definition at line 52 of file CSGLattice.C.

{
  std::vector<std::vector<std::string>> name_map;
  for (auto & univ_list : _universe_map)
  {
    std::vector<std::string> name_list;
    for (const CSGUniverse & univ : univ_list)
      name_list.push_back(univ.getName());
    name_map.push_back(name_list);
  }
  return name_map;
}

getUniverses()

std::vector<std::vector<std::reference_wrapper<const CSGUniverse> > > CSG::CSGLattice::getUniverses ( ) const

inline

Get the arrangement of CSGUniverses in the lattice.

Returns

list of list of universes in their lattice arrangement

Definition at line 97 of file CSGLattice.h.

Referenced by CSG::CSGBase::addLatticeToList(), CSG::CSGBase::createCell(), getUniqueUniverses(), and operator==().

  {
    return _universe_map;
  }

hasUniverse()

bool CSG::CSGLattice::hasUniverse

(

const std::string &

name

)

const

whether or not the universe of the specified name exists in the lattice

Parameters

name	of universe to search for

Returns

true if universe of that name exists in lattice

Definition at line 42 of file CSGLattice.C.

Referenced by getUniverseIndices().

{
  for (auto list_univ : _universe_map)
    for (const CSGUniverse & univ : list_univ)
      if (univ.getName() == name)
        return true;
  return false; // no universe with matching name was found
}

isValidIndex()

virtual bool CSG::CSGLattice::isValidIndex ( const std::pair< int, int >  index ) const

pure virtual

Checks if the given index location is a valid index for the lattice.

Parameters

index

location

Returns

true if index is valid for the lattice

Implemented in CSG::CSGCartesianLattice, and CSG::CSGHexagonalLattice.

Referenced by getUniverseAtIndex(), and setUniverseAtIndex().

isValidTransformationValue()

bool CSG::CSGTransformationHelper::isValidTransformationValue ( TransformationType  type, const std::tuple< Real, Real, Real > &  values  )

staticinherited

Check if the transformation value is valid for the given type.

Parameters

type	The type of transformation
values	The values for the transformation

Returns

True if the values are valid for the type

Definition at line 26 of file CSGTransformationHelper.C.

Referenced by CSG::CSGTransformationHelper::addTransformation().

{
  // Additional validation specific to each transformation type could be added here
  switch (type)
  {
    case TransformationType::TRANSLATION:
      // All translation values are inherently valid
      return true;

    case TransformationType::ROTATION:
      // Rotation uses euler notation; values are angles in degrees (phi, theta, psi)
      // For consistency with TransformGenerator, there are no restrictions on the angles
      // phi: rotation around Z-axis
      // theta: rotation around new X-axis
      // psi: rotation around new Z-axis
      return true;

    case TransformationType::SCALE:
      // Scaling factors should be non-zero
      if (std::get<0>(values) == 0.0 || std::get<1>(values) == 0.0 || std::get<2>(values) == 0.0)
        return false;
      return true;

    default:
      mooseError("Unknown transformation type");
  }
}

isValidUniverseMap()

virtual bool CSG::CSGLattice::isValidUniverseMap ( std::vector< std::vector< std::reference_wrapper< const CSGUniverse >>>  universes ) const

pure virtual

check that any provided list of list of CSGUniverses are the correct dimensions for the type of lattice

Parameters

universes

list of list of universes to be used to define the lattice structure

Returns

true if universe dimensions are valid

Implemented in CSG::CSGHexagonalLattice, and CSG::CSGCartesianLattice.

operator!=()

bool CSG::CSGLattice::operator!=

(

const CSGLattice &

other

)

const

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

Definition at line 189 of file CSGLattice.C.

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

operator==()

bool CSG::CSGLattice::operator==

(

const CSGLattice &

other

)

const

Operator overload for checking if two CSGLattice objects are equal.

Definition at line 153 of file CSGLattice.C.

{
  if (this->getName() != other.getName())
    return false;
  if (this->getType() != other.getType())
    return false;
  if (this->getTransformations() != other.getTransformations())
    return false;
  if (this->getOuterType() != other.getOuterType())
    return false;
  if ((this->getOuterType() == "CSG_MATERIAL") &&
      (this->getOuterMaterial() != other.getOuterMaterial()))
    return false;
  if ((this->getOuterType() == "UNIVERSE") &&
      (this->getOuterUniverse() != other.getOuterUniverse()))
    return false;
  if (!this->compareAttributes(other))
    return false;

  const auto & this_univs = this->getUniverses();
  const auto & other_univs = other.getUniverses();
  if (this_univs.size() != other_univs.size())
    return false;
  for (unsigned int i = 0; i < this_univs.size(); ++i)
  {
    if (this_univs[i].size() != other_univs[i].size())
      return false;
    for (unsigned int j = 0; j < this_univs[i].size(); j++)
      if (this_univs[i][j].get() != other_univs[i][j].get())
        return false;
  }

  return true;
}

resetOuter()

void CSG::CSGLattice::resetOuter

(

)

reset the outer fill around the lattice elements to be VOID

Definition at line 145 of file CSGLattice.C.

Referenced by CSG::CSGBase::resetLatticeOuter().

{
  _outer_type = "VOID";
  _outer_material = "";
  _outer_universe = nullptr;
}

setName()

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

inlineprotected

Definition at line 183 of file CSGLattice.h.

{ _name = name; }

setUniverseAtIndex()

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

protected

replace the element at specified index in the lattice with the provided CSGUniverse.

This will check that the _universe_map has been initialized and that the index is valid.

Parameters

universe	universe to add to the lattice at the location index
index	location in lattice replace with provided universe

Definition at line 30 of file CSGLattice.C.

Referenced by CSG::CSGBase::setUniverseAtLatticeIndex().

{
  std::string base_msg = "Cannot set universe at location (" + std::to_string(index.first) + ", " +
                         std::to_string(index.second) + ") for lattice " + getName() + ". ";
  if (_universe_map.size() == 0)
    mooseError(base_msg + "Universe map has not been initialized.");
  if (!isValidIndex(index))
    mooseError(base_msg + "Not a valid location.");
  _universe_map[index.first][index.second] = universe;
}

setUniverses()

virtual void CSG::CSGLattice::setUniverses ( std::vector< std::vector< std::reference_wrapper< const CSGUniverse >>>  universes )

protectedpure virtual

assign the vectors of universes as the lattice elements

Parameters

universes

vector of vectors of universes to be set as lattice elements, ordering depends on derived class

Implemented in CSG::CSGHexagonalLattice, and CSG::CSGCartesianLattice.

Referenced by CSG::CSGBase::setLatticeUniverses().

updateOuter() [1/2]

void CSG::CSGLattice::updateOuter ( const std::string &  outer_name )

protected

Update the outer of the lattice to be the provided material name.

This will change outer type to CSG_MATERIAL even if it was a different type previously.

Parameters

outer_name

name of CSG material that will fill space around lattice elements

Definition at line 137 of file CSGLattice.C.

Referenced by CSGLattice(), and CSG::CSGBase::setLatticeOuter().

{
  _outer_type = "CSG_MATERIAL";
  _outer_material = outer_name;
  _outer_universe = nullptr;
}

updateOuter() [2/2]

void CSG::CSGLattice::updateOuter ( const CSGUniverse &  outer_universe )

protected

Update the outer of the lattice to be the provided universe.

This will change outer type to UNIVERSE even if it was a different type previously.

Parameters

outer_universe

pointer to outer universe that will fill space around lattice elements

Definition at line 129 of file CSGLattice.C.

{
  _outer_type = "UNIVERSE";
  _outer_universe = &outer_universe;
  _outer_material = "";
}

Friends And Related Function Documentation

CSGBase

friend class CSGBase

friend

Definition at line 239 of file CSGLattice.h.

CSGLatticeList

friend class CSGLatticeList

friend

Definition at line 237 of file CSGLattice.h.

Member Data Documentation

_lattice_type

const std::string CSG::CSGLattice::_lattice_type

protected

Type of lattice.

Definition at line 222 of file CSGLattice.h.

Referenced by getType().

_name

std::string CSG::CSGLattice::_name

protected

Name of lattice.

Definition at line 219 of file CSGLattice.h.

Referenced by getName(), and setName().

_outer_material

std::string CSG::CSGLattice::_outer_material

mutableprotected

name of the outer material

Definition at line 231 of file CSGLattice.h.

Referenced by getOuterMaterial(), resetOuter(), and updateOuter().

_outer_type

std::string CSG::CSGLattice::_outer_type

mutableprotected

An enum for type of outer fill for lattice.

Definition at line 228 of file CSGLattice.h.

Referenced by getOuterType(), resetOuter(), and updateOuter().

_outer_universe

const CSGUniverse* CSG::CSGLattice::_outer_universe

protected

outer object if fill is CSGUniverse

Definition at line 234 of file CSGLattice.h.

Referenced by getOuterUniverse(), resetOuter(), and updateOuter().

_transformations

std::vector<std::pair<TransformationType, std::tuple<Real, Real, Real> > > CSG::CSGTransformationHelper::_transformations

protectedinherited

List of transformations applied to this object.

Definition at line 92 of file CSGTransformationHelper.h.

Referenced by CSG::CSGTransformationHelper::addTransformation(), CSG::CSGTransformationHelper::applyReverseTransformsToPoint(), CSG::CSGTransformationHelper::getTransformations(), and CSG::CSGTransformationHelper::getTransformationsAsStrings().

_universe_map

std::vector<std::vector<std::reference_wrapper<const CSGUniverse> > > CSG::CSGLattice::_universe_map

protected

Universes in the arrangement of how they appear in the lattice; dimensions depends on lattice type.

Definition at line 225 of file CSGLattice.h.

Referenced by getUniverseAtIndex(), getUniverseIndices(), getUniverseNameMap(), getUniverses(), hasUniverse(), setUniverseAtIndex(), CSG::CSGCartesianLattice::setUniverses(), and CSG::CSGHexagonalLattice::setUniverses().

---

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

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