DuctedPinEngUnit is a CSGUniverseEngUnit that represents a pin cell structure (concentric cylinders surrounded by concentric ducted regions) using basic engineering-scale attributes, including geometry type (hex or square), ring radii, duct apothems, axial boundaries, and radial and axial region ID names for each region of the pin structure. More...

#include <DuctedPinEngUnit.h>

Inheritance diagram for CSG::DuctedPinEngUnit:

[legend]

Public Member Functions
	DuctedPinEngUnit (const std::string &name, const std::string &geometry_type, const std::vector< Real > &ring_radii, const std::vector< Real > &duct_apothems, const std::vector< std::vector< std::string > > &region_names, const std::vector< Real > &axial_plane_levels, const std::vector< std::string > &axial_plane_names)
	Constructor for DuctedPinEngUnit.

std::unordered_map< std::string, AttributeVariant >	getAttributes () const override
	Return the pin engeering unit attributes for this object.

const std::string &	getName () const override

bool	isEngUnit () const override

bool	operator== (const CSGUniverseEngUnit &other) const

bool	operator== (const CSGUniverse &other) const

bool	operator== (const CSGEngUnit &other) const

bool	operator!= (const CSGUniverseEngUnit &other) const

bool	operator!= (const CSGUniverse &other) const

bool	operator!= (const CSGEngUnit &other) const

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

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

const CSGCell &	getCell (const std::string &name)

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

const std::vector< std::reference_wrapper< const CSGCell > > &	getAllCells () const

bool	isRoot () const

const std::string	getBehavior () const

const std::string	getUnitType () const

Static Public Member Functions
static bool	isValidTransformationValue (TransformationType type, const std::tuple< Real, Real, Real > &values)

static std::string	getTransformationTypeString (TransformationType type)

Protected Member Functions
std::unique_ptr< CSGUniverseEngUnit >	clone () const override
	Return a deep copy of this unit.

void	expandUnit () override
	Represent the pin cell as a single universe that contains cells that define each region of the pin cell structure.

const std::string	getGeometryTypeString () const
	Get the geometry type as a string.

const CSGUniverse &	getExpandedUniverse () const

void	removeCell (const std::string &name)

void	removeAllCells ()

void	setName (const std::string &name)

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

Point	applyReverseTransformsToPoint (Point p) const

CSGBase &	getBase ()

std::unique_ptr< CSGBase >	releaseBase ()

void	addCell (const CSGCell &)=delete

void	addCell (const CSGCell &)=delete

	FRIEND_TEST (CSGUniverseTest, testGetCell)

	FRIEND_TEST (CSGUniverseTest, testAddCell)

	FRIEND_TEST (CSGUniverseTest, testRemoveCell)

	FRIEND_TEST (CSGUniverseTest, testRemoveAllCells)

	FRIEND_TEST (CSGUniverseTest, testSetName)

	FRIEND_TEST (CSGUniverseTest, testUniverseEquality)

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

	FRIEND_TEST (CSGUniverseTest, testGetCell)

	FRIEND_TEST (CSGUniverseTest, testAddCell)

	FRIEND_TEST (CSGUniverseTest, testRemoveCell)

	FRIEND_TEST (CSGUniverseTest, testRemoveAllCells)

	FRIEND_TEST (CSGUniverseTest, testSetName)

	FRIEND_TEST (CSGUniverseTest, testUniverseEquality)

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithTransform)

	FRIEND_TEST (CSGSurfaceTest, testHalfspaceWithNullTransform)

	FRIEND_TEST (CSGEngUnitTest, testEngUnitEqual)

Protected Attributes
std::string	_name

std::vector< std::reference_wrapper< const CSGCell > >	_cells

bool	_is_root

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

std::unique_ptr< CSGBase >	_internal_base

MooseEnum	_behavior

Private Attributes
const std::vector< Real >	_ring_radii
	List of ring radii of pin cell.

const std::vector< Real >	_duct_apothems
	List of duct apothems of pin cell.

std::vector< std::vector< std::string > >	_region_names
	Region IDs of pin cell.

std::vector< Real >	_axial_plane_levels
	Axial plane levels for an extruded pin cell.

std::vector< std::string >	_axial_plane_names
	Axial plane names for an extruded pin cell.

MooseEnum	_geometry_type {"Hex Square"}
	Geometry type of pin cell structure (hex or square)

Detailed Description

DuctedPinEngUnit is a CSGUniverseEngUnit that represents a pin cell structure (concentric cylinders surrounded by concentric ducted regions) using basic engineering-scale attributes, including geometry type (hex or square), ring radii, duct apothems, axial boundaries, and radial and axial region ID names for each region of the pin structure.

This engineering unit supports both 3D and 2D/infinite pin geometries.

Implements:

expandUnit(): creates a universe that represents the pin cell structure
clone(): returns a deep copy of the pin engineering unit
getAttributes(): returns duct_apothems, ring_radii, region_ids, and geometry_type

Definition at line 30 of file DuctedPinEngUnit.h.

Constructor & Destructor Documentation

◆ DuctedPinEngUnit()

CSG::DuctedPinEngUnit::DuctedPinEngUnit	(	const std::string &	name,
		const std::string &	geometry_type,
		const std::vector< Real > &	ring_radii,
		const std::vector< Real > &	duct_apothems,
		const std::vector< std::vector< std::string > > &	region_names,
		const std::vector< Real > &	axial_plane_levels,
		const std::vector< std::string > &	axial_plane_names
	)

Constructor for DuctedPinEngUnit.

Parameters

name	unique name of the unit
geometry_type	geometry type of pin cell ("Hex" or "Square")
ring_radii	list of ring radii of cylindrical pin regions, which need to be in ascending order
duct_apothems	list of duct apothems that surround cylindrical regions in pin, which need to be in ascending order
region_names	2-D vector of region names that represent each radial (cylindrical and ducted) region and axial region
axial_plane_levels	list of axial plane levels of extruded pin
axial_plane_names	list of axial plane names of extruded pin

Definition at line 19 of file DuctedPinEngUnit.C.

  : CSGUniverseEngUnit(name),
    _ring_radii(ring_radii),
    _duct_apothems(duct_apothems),
    _region_names(region_names),
    _axial_plane_levels(axial_plane_levels),
    _axial_plane_names(axial_plane_names)
{
  // Check radii in ascending order
  if (_ring_radii.size() > 1)
    for (const auto i : make_range(_ring_radii.size() - 1))
      if (_ring_radii[i] >= _ring_radii[i + 1])
        mooseError(
            "Ducted pin engineering unit must have ring radii defined in strictly ascending order");
 
  // Check duct apothems in ascending order
  if (_duct_apothems.size() > 1)
    for (const auto i : make_range(_duct_apothems.size() - 1))
      if (_duct_apothems[i] >= _duct_apothems[i + 1])
        mooseError("Ducted pin engineering unit must have duct apothems defined in strictly "
                   "ascending order");
 
  // Check axial plane levels in ascending order
  if (_axial_plane_levels.size() > 1)
    for (const auto i : make_range(_axial_plane_levels.size() - 1))
      if (_axial_plane_levels[i] >= _axial_plane_levels[i + 1])
        mooseError("Ducted pin engineering unit must have axial plane levels defined in strictly "
                   "ascending order");
 
  // Check size of axial plane names
  if (_axial_plane_levels.size() != _axial_plane_names.size())
    mooseError("Size of axial plane levels must match size of axial plane names");
 
  // Check size of region ids
  unsigned int n_axial = _axial_plane_levels.size() + 1;
  if (_region_names.size() != n_axial)
    mooseError("Size of region IDs must be one larger than the number of axial levels");
 
  unsigned int n_radial = _ring_radii.size() + _duct_apothems.size() + 1;
  for (const auto & region_names_radial : _region_names)
    if (region_names_radial.size() != n_radial)
      mooseError("Size of each entry in region IDs must be one larger than the number of radial "
                 "zones in pin");
 
  _geometry_type = geometry_type;
}

Member Function Documentation

◆ clone()

std::unique_ptr< CSGUniverseEngUnit > CSG::DuctedPinEngUnit::clone ( ) const

overrideprotectedvirtual

Return a deep copy of this unit.

Returns: unique_ptr to a new DuctedPinEngUnit with identical parameters

Implements CSG::CSGUniverseEngUnit.

Definition at line 86 of file DuctedPinEngUnit.C.

{
  return std::make_unique<DuctedPinEngUnit>(_name,
                                            getGeometryTypeString(),
                                            _ring_radii,
                                            _duct_apothems,
                                            _region_names,
                                            _axial_plane_levels,
                                            _axial_plane_names);
}

◆ expandUnit()

void CSG::DuctedPinEngUnit::expandUnit ( )

overrideprotectedvirtual

Represent the pin cell as a single universe that contains cells that define each region of the pin cell structure.

Implements CSG::CSGUniverseEngUnit.

Definition at line 98 of file DuctedPinEngUnit.C.

{
  const auto has_axial_levels = _axial_plane_levels.size() > 0;
  unsigned int n_axial = _axial_plane_levels.size() + 1;
  unsigned int n_ring = _ring_radii.size();
  std::vector<std::reference_wrapper<const CSG::PinUniverseEngUnit>> pin_units_by_axial_region;
 
  // Define pin universe engineering units for each axial level
  if (n_ring)
  {
    for (const auto i : make_range(n_axial))
    {
      auto unit_name = _name + "_pin_unit";
      if (has_axial_levels)
        unit_name += "_axial_" + std::to_string(i);
      std::vector<std::string> pin_fill_mats;
      for (const auto j : make_range(n_ring + 1))
        pin_fill_mats.push_back(_region_names[i][j]);
      // Create a PinUniverseEngUnit engineering unit and add it to CSGBase
      std::unique_ptr<CSG::PinUniverseEngUnit> pin_ptr =
          std::make_unique<CSG::PinUniverseEngUnit>(unit_name, _ring_radii, pin_fill_mats);
      auto & pin_unit = _internal_base->addEngUnit(std::move(pin_ptr));
      pin_units_by_axial_region.push_back(pin_unit);
    }
  }
 
  // Define CSGNPolygonUnit representing each duct unit and define all radial regions
  // created by the ducts
  std::vector<CSG::CSGRegion> radial_regions;
  CSG::CSGRegion inner_region, outer_region, radial_region;
  std::vector<std::reference_wrapper<const CSG::CSGNPolygonUnit>> duct_units_by_radial_region;
  for (const auto i : index_range(_duct_apothems))
  {
    const auto unit_name = _name + "_radial_duct_" + std::to_string(i);
    const auto n_sides = (getGeometryTypeString() == "Hex") ? 6 : 4;
    std::unique_ptr<CSG::CSGNPolygonUnit> duct_ptr =
        std::make_unique<CSG::CSGNPolygonUnit>(unit_name, n_sides, _duct_apothems[i]);
    auto & duct_unit = _internal_base->addEngUnit(std::move(duct_ptr));
    duct_units_by_radial_region.push_back(duct_unit);
 
    if (i == 0)
    {
      // We are in the innermost radial region, the radial region is inner_region
      inner_region = -duct_unit;
      radial_region = inner_region;
    }
    else
    {
      // For all other regions, the radial region is the intersection of inner_region and
      // outer_region
      outer_region = ~inner_region;
      inner_region = -duct_unit;
      radial_region = inner_region & outer_region;
    }
    radial_regions.push_back(radial_region);
  }
 
  // Define outermost region
  radial_region = radial_regions.empty() ? outer_region : ~inner_region;
  radial_regions.push_back(radial_region);
 
  // Define all axial surfaces and regions
  std::vector<CSG::CSGRegion> axial_regions;
  std::vector<std::reference_wrapper<const CSG::CSGSurface>> surfaces_by_axial_region;
  if (has_axial_levels)
    for (const auto i : make_range(n_axial))
    {
      // Create the axial plane and add it to _internal_base
      if (i != _axial_plane_levels.size())
      {
        auto axial_level = _axial_plane_levels[i];
        auto axial_surf_name = _axial_plane_names[i];
        std::unique_ptr<CSG::CSGSurface> plane_surf_ptr =
            std::make_unique<CSG::CSGPlane>(axial_surf_name, 0, 0, 1, axial_level);
        const auto & plane_surf = _internal_base->addSurface(std::move(plane_surf_ptr));
        surfaces_by_axial_region.push_back(plane_surf);
      }
 
      // Define each axial region. This will be one more than the number of axial planes
      CSG::CSGRegion axial_region;
      const auto & current_surf = surfaces_by_axial_region.back().get();
      if (i == 0)
        // First axial region is the negative halfspace of the first plane
        axial_region = -current_surf;
      else if (i == _axial_plane_levels.size())
        // Last axial region is the positive halfspace of the last plane
        axial_region = +current_surf;
      else
      {
        // All other axial regions are the intersection of the negative halfspace
        // of the current plane and the positive halfspace of the previous plane
        const auto & prev_surf = surfaces_by_axial_region[i - 1].get();
        axial_region = -current_surf & +prev_surf;
      }
      axial_regions.push_back(axial_region);
    }
 
  // Define all cells within pin domain and add to root universe of engineering unit
  for (const auto i : index_range(radial_regions))
  {
    const unsigned int radial_index = _ring_radii.size() + i;
    for (const auto j : make_range(has_axial_levels ? axial_regions.size() : 1))
    {
      auto cell_region = radial_regions[i];
      auto cell_name = _name + "_cell_radial_" + std::to_string(i);
      if (has_axial_levels)
      {
        // update name and region with axial info only if extruded
        const auto axial_region = axial_regions[j];
        if (cell_region.getRegionType() != CSG::CSGRegion::RegionType::EMPTY)
          cell_region &= axial_region;
        else
          cell_region = axial_region;
        cell_name += "_axial_" + std::to_string(j);
      }
      if (i == 0 && n_ring > 0)
        // For first radial region where pin rings exist, we fill cell with pin universe unit
        _internal_base->createCell(cell_name, pin_units_by_axial_region[j], cell_region);
      else
      {
        // Otherwise, we fill the region with a material fill based on the region name
        const auto mat_name = _region_names[j][radial_index];
        _internal_base->createCell(cell_name, mat_name, cell_region);
      }
    }
  }
}

◆ getAttributes()

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

overridevirtual

Return the pin engeering unit attributes for this object.

Returns: map containing: geometry_type (std::string), ring_radii (std::vector<Real>), duct_apothems (std::vector<Real>), region_names (std::vector<std::vector<std::string>>), and axial_plane_levels (std::vector<Real>)

Implements CSG::CSGUniverseEngUnit.

Definition at line 73 of file DuctedPinEngUnit.C.

{
  std::unordered_map<std::string, AttributeVariant> attr_map{
      {"duct_apothems", _duct_apothems},
      {"ring_radii", _ring_radii},
      {"region_names", _region_names},
      {"geometry_type", getGeometryTypeString()}};
  if (_axial_plane_levels.size())
    attr_map["axial_plane_levels"] = _axial_plane_levels;
  return attr_map;
}

◆ getGeometryTypeString()

const std::string CSG::DuctedPinEngUnit::getGeometryTypeString ( ) const

inlineprotected

Get the geometry type as a string.

Returns: geometry type string

Definition at line 82 of file DuctedPinEngUnit.h.

82{ return _geometry_type; }

Referenced by clone(), expandUnit(), and getAttributes().

Member Data Documentation

◆ _axial_plane_levels

std::vector<Real> CSG::DuctedPinEngUnit::_axial_plane_levels

private

Axial plane levels for an extruded pin cell.

Definition at line 95 of file DuctedPinEngUnit.h.

Referenced by clone(), DuctedPinEngUnit(), expandUnit(), and getAttributes().

◆ _axial_plane_names

std::vector<std::string> CSG::DuctedPinEngUnit::_axial_plane_names

private

Axial plane names for an extruded pin cell.

Definition at line 98 of file DuctedPinEngUnit.h.

Referenced by clone(), DuctedPinEngUnit(), and expandUnit().

◆ _duct_apothems

const std::vector<Real> CSG::DuctedPinEngUnit::_duct_apothems

private

List of duct apothems of pin cell.

Definition at line 89 of file DuctedPinEngUnit.h.

Referenced by clone(), DuctedPinEngUnit(), expandUnit(), and getAttributes().

◆ _geometry_type

MooseEnum CSG::DuctedPinEngUnit::_geometry_type {"Hex Square"}

private

Geometry type of pin cell structure (hex or square)

Definition at line 101 of file DuctedPinEngUnit.h.

101{"Hex Square"};

Referenced by DuctedPinEngUnit(), and getGeometryTypeString().

◆ _region_names

std::vector<std::vector<std::string> > CSG::DuctedPinEngUnit::_region_names

private

Region IDs of pin cell.

Definition at line 92 of file DuctedPinEngUnit.h.

Referenced by clone(), DuctedPinEngUnit(), expandUnit(), and getAttributes().

◆ _ring_radii

const std::vector<Real> CSG::DuctedPinEngUnit::_ring_radii

private

List of ring radii of pin cell.

Definition at line 86 of file DuctedPinEngUnit.h.

Referenced by clone(), DuctedPinEngUnit(), expandUnit(), and getAttributes().

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

reactor/include/csg/DuctedPinEngUnit.h
reactor/src/csg/DuctedPinEngUnit.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DuctedPinEngUnit()

Member Function Documentation

◆ clone()

◆ expandUnit()

◆ getAttributes()

◆ getGeometryTypeString()

Member Data Documentation

◆ _axial_plane_levels

◆ _axial_plane_names

◆ _duct_apothems

◆ _geometry_type

◆ _region_names

◆ _ring_radii