CSG::CSGHexagonalLattice Class Reference

CSGHexagonalLattice is the class for constructing hexagonal lattices of CSGUniverses arranged in concentric hexagonal rings. More...

#include <CSGHexagonalLattice.h>

Inheritance diagram for CSG::CSGHexagonalLattice:

Public Member Functions
	CSGHexagonalLattice (const std::string &name, Real pitch, std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > universes, const std::optional< OuterVariant > &outer=std::nullopt)
	Construct a new CSGHexagonalLattice from a map of universes.
	CSGHexagonalLattice (const std::string &name, Real pitch, const std::optional< OuterVariant > &outer=std::nullopt)
	Construct a new empty CSGHexagonalLattice with the specified pitch.
virtual	~CSGHexagonalLattice ()=default
	Destructor.
std::unique_ptr< CSGLattice >	clone () const override
	clone this hexagonal lattice
virtual std::unordered_map< std::string, AttributeVariant >	getAttributes () const override
	Get attributes that define the lattice (excluding the universe map).
virtual bool	isValidIndex (const std::pair< int, int > index) const override
	check if provided index in row-column form is valid for the given hexagonal lattice
virtual bool	isValidUniverseMap (std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > universes) const override
	check if the arrangement of the provided universes is valid for the hexagonal lattice given the number or rows/rings defined for the lattice.
unsigned int	getNRows () const
	get number of rows in the lattices
unsigned int	getNRings () const
	get number of rings in the lattice
std::pair< int, int >	getRowIndexFromRingIndex (const std::pair< int, int > &row_col_index) const
	Given an index in ring-position form, get the corresponding row-column index.
std::pair< int, int >	getRingIndexFromRowIndex (const std::pair< int, int > &row_col_index) const
	Given an index in row-column form, get the corresponding ring-position index.
Real	getPitch () const
	get the pitch of the lattice
void	setPitch (Real pitch)
	set the pitch of the lattice
const std::string &	getName () const
	Get the name of lattice.
const std::string	getType () const
	Get the lattice type.
const std::string	getOuterType () const
	Get the type of outer that fills the space around the lattice elements.
const CSGUniverse &	getOuterUniverse () const
	Get the outer universe if outer type is UNIVERSE.
const std::string &	getOuterMaterial () const
	Get the outer material name if outer fype is CSG_MATERIAL.
std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > >	getUniverses () const
	Get the arrangement of CSGUniverses in the lattice.
const std::vector< std::vector< std::string > >	getUniverseNameMap () const
	Get the arrangement of CSGUniverses in the lattice as their names.
bool	hasUniverse (const std::string &name) const
	whether or not the universe of the specified name exists in the lattice
const CSGUniverse &	getUniverseAtIndex (const std::pair< int, int > index)
	Get the universe located at the given index.
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
void	resetOuter ()
	reset the outer fill around the lattice elements to be VOID
const std::vector< std::reference_wrapper< const CSGUniverse > >	getUniqueUniverses () const
	Get the list of unique universe objects in the lattice.
bool	operator== (const CSGLattice &other) const
	Operator overload for checking if two CSGLattice objects are equal.
bool	operator!= (const CSGLattice &other) const
	Operator overload for checking if two CSGLattice objects are not equal.
const std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > > &	getTransformations () const
	Get the list of transformations.
std::vector< std::pair< std::string, std::tuple< Real, Real, Real > > >	getTransformationsAsStrings () const
	Get the transformations of this object with string representations for types.

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.
static std::string	getTransformationTypeString (TransformationType type)
	Get the string representation of the transformation type.

Protected Member Functions
virtual bool	compareAttributes (const CSGLattice &other) const override
	compare the attributes returned in getAttributes of this lattice to another lattice
void	buildIndexMap ()
	build a mapping of row-column indices to ring-position indices for quick conversion and look-up.
virtual void	setUniverses (std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > > universes) override
	set the universes that define the lattice layout
void	setName (const std::string &name)
void	setUniverseAtIndex (const CSGUniverse &universe, const std::pair< int, int > index)
	replace the element at specified index in the lattice with the provided CSGUniverse.
void	updateOuter (const std::string &outer_name)
	Update the outer of the lattice to be the provided material name.
void	updateOuter (const CSGUniverse &outer_universe)
	Update the outer of the lattice to be the provided universe.
void	addTransformation (TransformationType type, const std::tuple< Real, Real, Real > &values)
	Add a transformation to the list of transformations.
Point	applyReverseTransformsToPoint (Point p) const
	update the value of point p by applying the inverse of the list of transformations to the point
	FRIEND_TEST (CSGLatticeTest, testHexSetUniverses)
	Friends for unit testing.
	FRIEND_TEST (CSGLatticeTest, testConvertRowsRings)
	FRIEND_TEST (CSGLatticeTest, testSetName)
	Friends for unit testing.
	FRIEND_TEST (CSGLatticeTest, testUpdateOuter)
	FRIEND_TEST (CSGBaseTest, testAddLattice)
	FRIEND_TEST (CSGLatticeTest, testCartLatticeEquality)
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)
	Friends for unit testing.
	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)
	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
Real	_pitch
	lattice pitch (flat-to-flat distance between adjacent hex elements)
unsigned int	_nrow
	number of rows in the hexagonal lattice (must be odd), should be consistent with the number of rings
unsigned int	_nring
	number of rings in the hexagonal lattice, should be consistent with the number of rows
std::map< std::pair< unsigned int, unsigned int >, std::pair< unsigned int, unsigned int > >	_row_to_ring_map
	map of row-column indices to ring-position indices for quick conversion and look-up
std::string	_name
	Name of lattice.
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.
std::string	_outer_type
	An enum for type of outer fill for lattice.
std::string	_outer_material
	name of the outer material
const CSGUniverse *	_outer_universe
	outer object if fill is CSGUniverse
std::vector< std::pair< TransformationType, std::tuple< Real, Real, Real > > >	_transformations
	List of transformations applied to this object.

Detailed Description

CSGHexagonalLattice is the class for constructing hexagonal lattices of CSGUniverses arranged in concentric hexagonal rings.

Definition at line 25 of file CSGHexagonalLattice.h.

Constructor & Destructor Documentation

CSGHexagonalLattice() [1/2]

CSG::CSGHexagonalLattice::CSGHexagonalLattice	(	const std::string &	name,
		Real	pitch,
		std::vector< std::vector< std::reference_wrapper< const CSGUniverse > > >	universes,
		const std::optional< OuterVariant > &	outer = std::nullopt
	)

Construct a new CSGHexagonalLattice from a map of universes.

Universes should be arranged by rows and correspond to a hexagonal lattice with x-orientation.

Parameters

name	unique identifying name of lattice
pitch	flat-to-flat distance for one hexagonal lattice element
universes	row-wise ragged vector of universes representing hex pattern
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 15 of file CSGHexagonalLattice.C.

  : CSGLattice(name, outer), _pitch(pitch)
{
  setUniverses(universes); // this will set _nrow
  if (_pitch < 0)
    mooseError("Lattice " + getName() + " must have pitch greater than 0.");
}

CSGHexagonalLattice() [2/2]

CSG::CSGHexagonalLattice::CSGHexagonalLattice	(	const std::string &	name,
		Real	pitch,
		const std::optional< OuterVariant > &	outer = std::nullopt
	)

Construct a new empty CSGHexagonalLattice with the specified pitch.

NOTE: must call setLatticeUniverses to populate universe map.

Parameters

name	unique identifying name of lattice
pitch	flat-to-flat distance for one hexagonal lattice element
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 27 of file CSGHexagonalLattice.C.

  : CSGLattice(name, outer), _pitch(pitch), _nrow(0), _nring(0)
{
  if (_pitch < 0)
    mooseError("Lattice " + getName() + " must have pitch greater than 0.");
}

~CSGHexagonalLattice()

virtual CSG::CSGHexagonalLattice::~CSGHexagonalLattice ( )

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

Referenced by CSG::CSGBase::addTransformation(), CSG::CSGBase::expandEngUnit(), CSG::CSGBase::expandEngUnit(), and CSG::CSGBase::expandEngUnit().

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.

{
  // 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;
}

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

buildIndexMap()

void CSG::CSGHexagonalLattice::buildIndexMap ( )

protected

build a mapping of row-column indices to ring-position indices for quick conversion and look-up.

Sets the _row_to_ring_map variable.

Definition at line 126 of file CSGHexagonalLattice.C.

{
  for (const auto ring : make_range(_nring))
  {
    unsigned int num_elements = (ring == _nring - 1) ? 1 : 6 * (_nring - 1 - ring);
    for (const auto element : make_range(num_elements))
    {
      std::pair<unsigned int, unsigned int> ring_index = std::make_pair(ring, element);
      std::pair<unsigned int, unsigned int> row_index = getRowIndexFromRingIndex(ring_index);
      _row_to_ring_map[row_index] = ring_index;
    }
  }
}

Referenced by setUniverses().

clone()

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

inlineoverridevirtual

clone this hexagonal lattice

Returns

std::unique_ptr<CSGLattice> unique pointer to cloned hexagonal lattice

Implements CSG::CSGLattice.

Definition at line 66 of file CSGHexagonalLattice.h.

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

compareAttributes()

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

overrideprotectedvirtual

compare the attributes returned in getAttributes of this lattice to another lattice

Implements CSG::CSGLattice.

Definition at line 109 of file CSGHexagonalLattice.C.

{
  if (other.getType() != this->getType())
    return false;
 
  auto this_dims = this->getAttributes();
  auto other_dims = other.getAttributes();
  if (std::get<unsigned int>(this_dims["nrow"]) != std::get<unsigned int>(other_dims["nrow"]))
    return false;
  if (std::get<unsigned int>(this_dims["nring"]) != std::get<unsigned int>(other_dims["nring"]))
    return false;
  if (std::get<Real>(this_dims["pitch"]) != std::get<Real>(other_dims["pitch"]))
    return false;
  return true;
}

FRIEND_TEST() [1/9]

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

protectedinherited

FRIEND_TEST() [2/9]

CSG::CSGTransformationHelper::FRIEND_TEST ( CSGEngUnitTest  , testEngUnitEqual    )

protectedinherited

FRIEND_TEST() [3/9]

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

protectedinherited

FRIEND_TEST() [4/9]

CSG::CSGHexagonalLattice::FRIEND_TEST ( CSGLatticeTest  , testConvertRowsRings    )

protected

FRIEND_TEST() [5/9]

CSG::CSGHexagonalLattice::FRIEND_TEST ( CSGLatticeTest  , testHexSetUniverses    )

protected

Friends for unit testing.

FRIEND_TEST() [6/9]

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

protectedinherited

Friends for unit testing.

FRIEND_TEST() [7/9]

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

protectedinherited

FRIEND_TEST() [8/9]

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

protectedinherited

FRIEND_TEST() [9/9]

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

protectedinherited

Friends for unit testing.

getAttributes()

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

overridevirtual

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

• nrow: number of rows in the hex lattice (int)
• pitch: pitch of the lattice element (Real)

Returns

map of string dimension name to value of that dimension

Implements CSG::CSGLattice.

Definition at line 83 of file CSGHexagonalLattice.C.

{
  return {{"nrow", static_cast<unsigned int>(_nrow)},
          {"nring", static_cast<unsigned int>(_nring)},
          {"pitch", _pitch}};
}

Referenced by compareAttributes().

getName()

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

inlineinherited

Get the name of lattice.

Returns

std::string name of lattice

Definition at line 60 of file CSGLattice.h.

{ return _name; }

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

getNRings()

unsigned int CSG::CSGHexagonalLattice::getNRings ( ) const

inline

get number of rings in the lattice

Returns

number of rings

Definition at line 111 of file CSGHexagonalLattice.h.

{ return _nring; }

getNRows()

unsigned int CSG::CSGHexagonalLattice::getNRows ( ) const

inline

get number of rows in the lattices

Returns

number of rows

Definition at line 104 of file CSGHexagonalLattice.h.

{ return _nrow; }

getOuterMaterial()

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

inherited

Get the outer material name if outer fype is CSG_MATERIAL.

Returns

name of the CSG material fill

Definition at line 118 of file CSGLattice.C.

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

Referenced by CSG::CSGLattice::operator==().

getOuterType()

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

inlineinherited

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 77 of file CSGLattice.h.

{ return _outer_type; }

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

getOuterUniverse()

const CSGUniverse & CSG::CSGLattice::getOuterUniverse ( ) const

inherited

Get the outer universe if outer type is UNIVERSE.

Returns

Reference to CSGUniverse

Definition at line 109 of file CSGLattice.C.

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

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

getPitch()

Real CSG::CSGHexagonalLattice::getPitch ( ) const

inline

get the pitch of the lattice

Returns

pitch

Definition at line 172 of file CSGHexagonalLattice.h.

{ return _pitch; }

getRingIndexFromRowIndex()

std::pair< int, int > CSG::CSGHexagonalLattice::getRingIndexFromRowIndex

(

const std::pair< int, int > &

row_col_index

)

const

Given an index in row-column form, get the corresponding ring-position index.

The row-column form assumes the top row is the 0th row and is indexed from left to right. The ring-position form assumes the outermost ring is the 0th ring and is indexed starting from the rightmost position of the ring and proceeding counter-clockwise around the ring.

Example of corresponding indices for a hexagonal lattice with 3 rings (5 rows):

Row-Column Form: (0,0) (0,1) (0,2) (1,0) (1,1) (1,2) (1,3) (2,0) (2,1) (2,2) (2,3) (2,4) (3,0) (3,1) (3,2) (3,3) (4,0) (4,1) (4,2)

Ring-Position Form: (0,8) (0,9) (0,10) (0,7) (1,4) (1,5) (0,11) (0,6) (1,3) (2,0) (1,0) (0,0) (0,5) (1,2) (1,1) (0,1) (0,4) (0,3) (0,2)

Parameters

index

in row-column form

Returns

index in ring-position form

Definition at line 221 of file CSGHexagonalLattice.C.

{
  if (!isValidIndex(row_col_index))
    mooseError("Index (" + std::to_string(row_col_index.first) + ", " +
               std::to_string(row_col_index.second) +
               ") is not a valid index for hexagonal "
               "lattice " +
               getName());
 
  return _row_to_ring_map.at(row_col_index);
}

getRowIndexFromRingIndex()

std::pair< int, int > CSG::CSGHexagonalLattice::getRowIndexFromRingIndex

(

const std::pair< int, int > &

row_col_index

)

const

Given an index in ring-position form, get the corresponding row-column index.

The ring-position form assumes the outermost ring is the 0th ring and is indexed starting from the rightmost position of the ring and proceeding counter-clockwise around the ring. The row-column form assumes the top row is the 0th row and is indexed from left to right.

Example of corresponding indices for a hexagonal lattice with 3 rings (5 rows):

Row-Column Form: (0,0) (0,1) (0,2) (1,0) (1,1) (1,2) (1,3) (2,0) (2,1) (2,2) (2,3) (2,4) (3,0) (3,1) (3,2) (3,3) (4,0) (4,1) (4,2)

Ring-Position Form: (0,8) (0,9) (0,10) (0,7) (1,4) (1,5) (0,11) (0,6) (1,3) (2,0) (1,0) (0,0) (0,5) (1,2) (1,1) (0,1) (0,4) (0,3) (0,2)

Parameters

index

in ring-position form

Returns

index in row-column form

Definition at line 141 of file CSGHexagonalLattice.C.

{
  auto og_ring = ring_ele_index.first; // ring corresponds to the outermost ring as ring 0
  int ring = _nring - og_ring - 1;     // convert to internal indexing (0 as innermost ring)
  auto element = ring_ele_index.second;
 
  if (og_ring < 0 || og_ring >= (int)_nring)
    mooseError("Ring " + std::to_string(og_ring) + " is not valid for hexagonal lattice " +
               getName());
  if (element < 0 || element >= (ring == 0 ? 1 : 6 * ring))
    mooseError("Position " + std::to_string(element) + " is not valid for ring " +
               std::to_string(og_ring) + " in hexagonal lattice " + getName());
 
  // Calculate the center row and column indices
  int center_row = (_nrow - 1) / 2;
  int center_col = center_row;
 
  // Special case for the center element
  if (ring == 0)
    return {center_row, center_col};
 
  // Calculate the side length of the hexagon for the given ring
  int side_length = ring;
 
  // Determine which side of the hexagon the element is on and get row/col from this
  int side = element / side_length;
  int offset = element % side_length; // position within the side moving counter-clockwise
  int row, col;
 
  // lamba to calculate the number of columns in any given row
  auto calc_num_cols_in_row = [&](int r) { return _nrow - std::abs(center_row - r); };
 
  // diagram of side numbers:
  //            4
  //         _______
  //       /         \*
  //    3 /           \ 5
  //     /             \*
  //     \             /
  //    2 \           / 0
  //       \ _______ /
  //            1
  switch (side)
  {
    case 0: // bottom right (contains starting position of the ring)
      row = center_row + offset;
      col = calc_num_cols_in_row(row) - og_ring - 1;
      break;
    case 1: // bottom
      row = center_row + ring;
      col = calc_num_cols_in_row(row) - og_ring - 1 - offset;
      break;
    case 2: // bottom left
      row = center_row + (side_length - offset);
      col = center_col - ring;
      break;
    case 3: // top left
      row = center_row - offset;
      col = center_col - ring;
      break;
    case 4: // top
      row = center_row - ring;
      col = center_col - ring + offset;
      break;
    case 5: // top right
      row = center_row - (side_length - offset);
      col = calc_num_cols_in_row(row) - og_ring - 1;
      break;
    default:
      mooseError("Invalid side ID calculation in hexagonal lattice " + getName());
  }
 
  mooseAssert(isValidIndex(std::make_pair(row, col)),
              "Calculated index (" + std::to_string(row) + ", " + std::to_string(col) +
                  ") is not valid for hexagonal lattice " + getName());
 
  return {row, col};
}

Referenced by buildIndexMap().

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 51 of file CSGTransformationHelper.h.

  {
    return _transformations;
  }

Referenced by CSG::CSGSurface::getHalfspaceFromPoint(), CSG::CSGCellEngUnit::getTransformations(), CSG::CSGSurfaceEngUnit::getTransformations(), CSG::CSGUniverseEngUnit::getTransformations(), CSG::CSGCell::operator==(), CSG::CSGLattice::operator==(), CSG::CSGSurface::operator==(), and CSG::CSGUniverse::operator==().

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

Referenced by CSG::CSGCellEngUnit::getTransformationsAsStrings(), CSG::CSGSurfaceEngUnit::getTransformationsAsStrings(), and CSG::CSGUniverseEngUnit::getTransformationsAsStrings().

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.

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

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

getType()

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

inlineinherited

Get the lattice type.

Returns

std::string type of lattice

Definition at line 67 of file CSGLattice.h.

  {
    return MooseUtils::prettyCppType(libMesh::demangle(typeid(*this).name()));
  }

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

getUniqueUniverses()

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

inherited

Get the list of unique universe objects in the lattice.

Returns

list of references to unique CSGUniverse objects

Definition at line 91 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 )

inherited

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 64 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

inherited

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 74 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

inherited

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

Returns

list of list of universe names

Definition at line 50 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

inlineinherited

Get the arrangement of CSGUniverses in the lattice.

Returns

list of list of universes in their lattice arrangement

Definition at line 98 of file CSGLattice.h.

  {
    return _universe_map;
  }

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

hasUniverse()

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

inherited

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 40 of file CSGLattice.C.

{
  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
}

Referenced by CSG::CSGLattice::getUniverseIndices().

isValidIndex()

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

overridevirtual

check if provided index in row-column form is valid for the given hexagonal lattice

Parameters

index

in row-column form

Returns

true if valid, otherwise false

Implements CSG::CSGLattice.

Definition at line 91 of file CSGHexagonalLattice.C.

{
  auto row = index.first;  // row index
  auto ele = index.second; // column index within the row
 
  // Check if row is valid (0 <= row < _nrow)
  if (row < 0 || row >= (int)_nrow)
    return false;
 
  // Calculate maximum number of elements in this specific row
  auto center_row = (_nrow - 1) / 2; // center row index
  int max_ele = _nrow - std::abs((int)(row - center_row));
 
  // Check if column index is valid for this row
  return !(ele < 0 || ele >= max_ele);
}

Referenced by getRingIndexFromRowIndex(), and getRowIndexFromRingIndex().

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.

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

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

isValidUniverseMap()

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

overridevirtual

check if the arrangement of the provided universes is valid for the hexagonal lattice given the number or rows/rings defined for the lattice.

Universes should be listed by row, starting from the top, and assume an x-orientation arrangment.

Parameters

universes

list of lists of universes that define the arrangement of the lattice

Returns

true if valid, otherwise false

Implements CSG::CSGLattice.

Definition at line 37 of file CSGHexagonalLattice.C.

{
  if (universes.size() < 1) // need at least one row
    return false;
 
  if (universes.size() % 2 == 0) // must be odd number of rows
    return false;
 
  // each row differs in how many elements are required depending on size of lattice
  unsigned int num_row = universes.size();
  unsigned int center_row = (num_row - 1) / 2;
  for (unsigned int row_i : index_range(universes))
  {
    unsigned int n_ele =
        num_row - ((row_i > center_row) ? (row_i - center_row) : (center_row - row_i));
    if (universes[row_i].size() != n_ele)
      return false;
  }
 
  return true;
}

Referenced by setUniverses().

operator!=()

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

inherited

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

Definition at line 187 of file CSGLattice.C.

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

operator==()

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

inherited

Operator overload for checking if two CSGLattice objects are equal.

Definition at line 151 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 ( )

inherited

reset the outer fill around the lattice elements to be VOID

Definition at line 143 of file CSGLattice.C.

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

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

setName()

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

inlineprotectedinherited

Definition at line 184 of file CSGLattice.h.

{ _name = name; }

setPitch()

void CSG::CSGHexagonalLattice::setPitch

(

Real

pitch

)

set the pitch of the lattice

Parameters

pitch

new pitch value

Definition at line 75 of file CSGHexagonalLattice.C.

{
  if (pitch < 0)
    mooseError("Lattice " + getName() + " must have pitch greater than 0.");
  _pitch = pitch;
}

setUniverseAtIndex()

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

protectedinherited

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 28 of file CSGLattice.C.

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

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

setUniverses()

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

overrideprotectedvirtual

set the universes that define the lattice layout

Parameters

universes

list of list of universes to set as the lattice map

Implements CSG::CSGLattice.

Definition at line 61 of file CSGHexagonalLattice.C.

{
  // check for valid map arrangment
  if (!isValidUniverseMap(universes))
    mooseError("Cannot set lattice " + getName() +
               " with universes. Does not have valid dimensions for lattice type " + getType());
  // set attributes based on universe map (in case they differ from original values)
  _nrow = universes.size();
  _nring = nRowToRing(_nrow);
  _universe_map = universes;
  buildIndexMap();
}

Referenced by CSGHexagonalLattice().

updateOuter() [1/2]

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

protectedinherited

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 127 of file CSGLattice.C.

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

updateOuter() [2/2]

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

protectedinherited

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 135 of file CSGLattice.C.

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

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

Member Data Documentation

_name

std::string CSG::CSGLattice::_name

protectedinherited

Name of lattice.

Definition at line 220 of file CSGLattice.h.

Referenced by CSG::CSGLattice::getName(), and CSG::CSGLattice::setName().

_nring

unsigned int CSG::CSGHexagonalLattice::_nring

protected

number of rings in the hexagonal lattice, should be consistent with the number of rows

Definition at line 206 of file CSGHexagonalLattice.h.

Referenced by buildIndexMap(), getAttributes(), getNRings(), getRowIndexFromRingIndex(), and setUniverses().

_nrow

unsigned int CSG::CSGHexagonalLattice::_nrow

protected

number of rows in the hexagonal lattice (must be odd), should be consistent with the number of rings

Definition at line 203 of file CSGHexagonalLattice.h.

Referenced by getAttributes(), getNRows(), getRowIndexFromRingIndex(), isValidIndex(), and setUniverses().

_outer_material

std::string CSG::CSGLattice::_outer_material

mutableprotectedinherited

name of the outer material

Definition at line 229 of file CSGLattice.h.

Referenced by CSG::CSGLattice::getOuterMaterial(), CSG::CSGLattice::resetOuter(), CSG::CSGLattice::updateOuter(), and CSG::CSGLattice::updateOuter().

_outer_type

std::string CSG::CSGLattice::_outer_type

mutableprotectedinherited

An enum for type of outer fill for lattice.

Definition at line 226 of file CSGLattice.h.

Referenced by CSG::CSGLattice::getOuterType(), CSG::CSGLattice::resetOuter(), CSG::CSGLattice::updateOuter(), and CSG::CSGLattice::updateOuter().

_outer_universe

const CSGUniverse* CSG::CSGLattice::_outer_universe

protectedinherited

outer object if fill is CSGUniverse

Definition at line 232 of file CSGLattice.h.

Referenced by CSG::CSGLattice::getOuterUniverse(), CSG::CSGLattice::resetOuter(), CSG::CSGLattice::updateOuter(), and CSG::CSGLattice::updateOuter().

_pitch

Real CSG::CSGHexagonalLattice::_pitch

protected

lattice pitch (flat-to-flat distance between adjacent hex elements)

Definition at line 200 of file CSGHexagonalLattice.h.

Referenced by CSGHexagonalLattice(), CSGHexagonalLattice(), getAttributes(), getPitch(), and setPitch().

_row_to_ring_map

std::map<std::pair<unsigned int, unsigned int>, std::pair<unsigned int, unsigned int> > CSG::CSGHexagonalLattice::_row_to_ring_map

protected

map of row-column indices to ring-position indices for quick conversion and look-up

Definition at line 210 of file CSGHexagonalLattice.h.

Referenced by buildIndexMap(), and getRingIndexFromRowIndex().

_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 96 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

protectedinherited

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

Definition at line 223 of file CSGLattice.h.

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

---

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

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