Class providing various utility functions related to triangular lattices of pins enclosed in a hexagonal duct. More...

#include <HexagonalLatticeUtils.h>

Public Member Functions
	HexagonalLatticeUtils (const Real bundle_inner_flat_to_flat, const Real pin_pitch, const Real pin_diameter, const Real wire_diameter, const Real wire_pitch, const unsigned int n_rings, const unsigned int axis, const Real rotation_around_axis=0)

Real	distanceFromGap (const Point &pt, const unsigned int gap_index) const
	Distance from a point and a gap.

unsigned int	gapIndex (const Point &point) const
	Get the index for the gap closest to the point.

void	gapIndexAndDistance (const Point &point, unsigned int &index, Real &distance) const
	Get the gap index and distance to that gap for a given point.

Real	sideTranslationX (const unsigned int side) const
	Get the unit vector translation to move a center point to a duct wall.

Real	sideTranslationY (const unsigned int side) const
	Get the unit vector translation to move a center point to a duct wall.

unsigned int	firstPinInRing (const unsigned int ring) const
	Get the index of the "first" pin in a ring.

unsigned int	lastPinInRing (const unsigned int ring) const
	Get the index of the "last" pin in a ring.

bool	lastGapInRing (const unsigned int gap_index) const
	Whether this gap is the "last" in the ring, i.e.

unsigned int	ringIndex (const unsigned int pin) const
	Get the index of the ring for a certain pin index.

const std::vector< Point > &	gapUnitNormals () const
	Get the unit normals for all of the gaps.

unsigned int	pins (const unsigned int n) const
	Get the number of pins in a given ring.

unsigned int	totalPins (const unsigned int n) const
	Get the total number of pins for all rings.

unsigned int	rings (const unsigned int n) const
	Get the number of rings for a specified number of pins.

unsigned int	interiorChannels (const unsigned int ring)
	Get the number of interior channels between ring and ring - 1 (0 indexing)

unsigned int	nInteriorGaps () const
	Get the number of gaps that touch an interior channel.

const std::vector< Point > &	gapCenters () const
	Get the center coordinates of the gaps.

unsigned int	nGaps () const
	Get the number of gaps.

Real	pitchToDiameter () const
	Get the (pin) pitch-to-diameter ratio.

Real	heightToDiameter () const
	Get the (wire) axial pitch-to-diameter ratio.

unsigned int	axis () const
	Get the vertical axis of the bed along which pins are aligned.

Real	pinDiameter () const
	Get the pin diameter.

Real	wirePitch () const
	Get the wire pitch.

Real	wireDiameter () const
	Get the wire diameter.

Real	pinPitch () const
	Get the pin pitch.

Real	bundlePitch () const
	Get the bundle pitch.

Real	pinVolumePerPitch () const
	Get the pin volume per pitch.

Real	wireVolumePerPitch () const
	Get the wire volume per pitch.

unsigned int	nInteriorPins () const
	Get the number of interior pins.

unsigned int	nEdgePins () const
	Get the number of edge pins.

unsigned int	nCornerPins () const
	Get the number of corner pins.

unsigned int	nPins () const
	Get the total number of pins for the lattice.

Real	interiorHydraulicDiameter () const
	Get the hydraulic diameter of an interior channel.

Real	edgeHydraulicDiameter () const
	Get the hydraulic diameter of an edge channel.

Real	cornerHydraulicDiameter () const
	Get the hydraulic diameter of a corner channel.

Real	hydraulicDiameter () const
	Get the overall bundle hydraulic diameter.

Real	interiorWettedArea () const
	Get the wetted area of an interior channel per wire pitch.

Real	edgeWettedArea () const
	Get the wetted area of an edge channel per wire pitch.

Real	cornerWettedArea () const
	Get the wetted area of a corner channel per wire pitch.

Real	wettedArea () const
	Get the wetted area of entire bundle per wire pitch.

Real	interiorFlowVolume () const
	Get the flow volume of an interior channel per wire pitch.

Real	edgeFlowVolume () const
	Get the flow volume of an edge channel per wire pitch.

Real	cornerFlowVolume () const
	Get the flow volume of an corner channel per wire pitch.

Real	interiorVolume () const
	Get the total volume of an interior channel per wire pitch.

Real	edgeVolume () const
	Get the total volume of an edge channel per wire pitch.

Real	cornerVolume () const
	Get the total volume of an corner channel per wire pitch.

Real	flowVolume () const
	Get the flow volume of the bundle per wire pitch.

unsigned int	nInteriorChannels () const
	Get the number of interior channels.

unsigned int	nEdgeChannels () const
	Get the number of edge channels.

unsigned int	nCornerChannels () const
	Get the number of corner channels.

unsigned int	nChannels () const
	Get the total number of channels.

Real	pinBundleSpacing () const
	Get the distance between the outermost pins and the duct walls.

const std::vector< Point > &	pinCenters () const
	Get the center coordinates of the pins.

const std::vector< std::vector< Point > > &	pinCenteredCornerCoordinates () const
	Get the corner coordinates of a hexagon surrounding each pin.

Real	pinSurfaceAreaPerPitch () const
	Get the pin surface area per wire pitch.

Real	cornerEdgeLength () const
	Get half the distance of the duct that a corner channel is in contact with.

Real	minDuctWallDistance (const Point &p) const
	Get the minimum distance from a point to the duct inner surface.

Real	minDuctCornerDistance (const Point &p) const
	Get the minimum distance from a point to the duct corners.

channel_type::ChannelTypeEnum	channelType (const Point &p) const
	Get the channel type (interior, edge, corner) given a point.

Real	channelSpecificSurfaceArea (const channel_type::ChannelTypeEnum &channel) const
	Get the specific surface area of a channel.

Real	channelHydraulicDiameter (const channel_type::ChannelTypeEnum &channel) const
	Get the hydraulic diameter of a channel.

Real	pinRadius () const
	Get the pin outer radius.

Real	hexagonArea (const Real pitch) const
	Get the area of a hexagon with given flat-to-flat distance (pitch)

Real	hexagonSide (const Real pitch) const
	Get the side length of a hexagon with given flat-to-flat distance (pitch)

Real	hexagonVolume (const Real side) const
	Get the volume of a hexagonal prism per wire pitch.

Real	hexagonPitch (const Real volume) const
	Get the pitch of a hexagonal prism based on its per-wire-pitch volume.

Real	triangleArea (const Real side) const
	Get the area of an equilateral triangle with given side length.

Real	triangleHeight (const Real side) const
	Get the height of an equilateral triangle with given side length.

Real	triangleSide (const Real height) const
	Get the side of an equilateral triangle with given height.

Real	triangleVolume (const Real side) const
	Get the volume of an equilateral triangle prism per wire pitch.

const std::vector< std::vector< unsigned int > > &	interiorChannelPinIndices () const
	Get the pin indices forming the corners of all interior channels.

const std::vector< std::vector< unsigned int > > &	edgeChannelPinIndices () const
	Get the pin indices forming two of the corners of all edge channels.

const std::vector< std::vector< unsigned int > > &	cornerChannelPinIndices () const
	Get the pin indices forming one of the corners of all corner channels.

const std::vector< std::pair< int, int > > &	gapIndices () const
	Get the pin and side indices on each gap.

const std::vector< std::vector< int > > &	localToGlobalGaps () const
	For each subchannel, get the indices of the gaps that touch that subchannel.

const std::vector< Point >	interiorChannelCornerCoordinates (const unsigned int interior_channel_id) const
	Get the corner coordinates of an interior channel given an ID (relative to the start of the interior channels)

const std::vector< Point >	edgeChannelCornerCoordinates (const unsigned int edge_channel_id) const
	Get the corner coordinates of an edge channel given an ID (relative to the start of the edge channels)

const std::vector< Point >	cornerChannelCornerCoordinates (const unsigned int corner_channel_id) const
	Get the corner coordinates of a corner channel given an ID (relative to the start of the corner channels)

Point	channelCentroid (const std::vector< Point > &corners) const
	Get the centroid of a channel given the corner coordinates.

unsigned int	pinIndex (const Point &point) const
	Get the pin index given a point.

unsigned int	closestPinIndex (const Point &point) const
	Get the closest pin index given a point outside the lattice.

unsigned int	channelIndex (const Point &point) const
	Get the channel index given a point.

bool	insideLattice (const Point &point) const
	Whether the point is inside the lattice.

void	get2DInputPatternIndex (const unsigned int pin_index, unsigned int &row_index, unsigned int &within_row_index) const
	Conversion from lattice pin indexing to the 2D input file index.

Protected Member Functions
unsigned int	globalGapIndex (const std::pair< int, int > &local_gap) const
	Get the global gap index from the local gap index.

Protected Attributes
const Real	_bundle_pitch
	Bundle pitch (distance across bundle measured flat-to-flat on the inside of the duct)

const Real	_pin_pitch
	Pin pitch.

const Real	_pin_diameter
	Pin diameter.

const Real	_wire_diameter
	Wire diameter.

const Real	_wire_pitch
	Wire pitch.

const unsigned int	_n_rings
	Total number of rings of pins.

const unsigned int	_axis
	Vertical axis of the bundle along which the pins are aligned.

const Real	_rotation_around_axis
	Rotation around the axis to apply to the lattice.

const RealTensorValue	_rotation_matrix
	Rotation matrix to apply the rotation why.

const Real	_bundle_side_length
	Side length of duct.

const Real	_pin_area
	Pin cross-sectional area.

const Real	_pin_circumference
	Pin circumference.

const Real	_wire_area
	Wire cross-sectional area.

const Real	_wire_circumference
	Wire circumference.

const Real	_pin_surface_area_per_pitch
	Pin surface area per wire pitch.

const Real	_pin_volume_per_pitch
	Single-pin volume per wire pitch.

const Real	_P_over_D
	Pitch-to-diameter ratio.

const Real	_L_over_D
	Wire axial lead length to diameter ratio.

Real	_wire_surface_area_per_pitch
	Wire surface area per wire pitch.

Real	_pin_bundle_spacing
	Spacing between the duct inner wall and the pin surface.

Real	_wire_volume_per_pitch
	Single-wire volume per wire pitch.

unsigned int	_n_pins
	Total number of pins.

unsigned int	_n_interior_pins
	Number of interior pins.

unsigned int	_n_edge_pins
	Number of edge pins.

unsigned int	_n_corner_pins
	Number of corner pins.

unsigned int	_n_channels
	Total number of channels.

unsigned int	_n_interior_channels
	Total number of interior channels.

unsigned int	_n_edge_channels
	Total number of edge channels.

unsigned int	_n_corner_channels
	Total number of corner channels.

Real	_corner_edge_length
	Half the distance for which a corner channel is in contact with the duct.

Real	_interior_Dh
	Hydraulic diameter of interior channel.

Real	_edge_Dh
	Hydraulic diameter of edge channel.

Real	_corner_Dh
	Hydraulic diameter of corner channel.

Real	_Dh
	Bundle-wide hydraulic diameter.

Real	_interior_flow_volume
	Flow volume of an interior channel per wire pitch.

Real	_edge_flow_volume
	Flow volume of an edge channel per wire pitch.

Real	_corner_flow_volume
	Flow volume of a corner channel per wire pitch.

Real	_interior_volume
	Total volume of an interior channel per wire pitch.

Real	_edge_volume
	Total volume of an edge channel per wire pitch.

Real	_corner_volume
	Total volume of a corner channel per wire pitch.

Real	_flow_volume
	Bundle-wide flow volume per wire pitch.

Real	_interior_wetted_area
	Wetted area of an interior channel per wire pitch.

Real	_edge_wetted_area
	Wetted area of an edge channel per wire pitch.

Real	_corner_wetted_area
	Wetted area of a corner channel per wire pitch.

Real	_wetted_area
	Wetted area of entire bundle per wire pitch.

std::vector< Point >	_pin_centers
	Pin center coordinates.

std::vector< std::vector< Point > >	_pin_centered_corner_coordinates
	Corner coordinates of a hexagon surrounding each pin.

std::vector< Point >	_duct_corners
	Six corner coordinates for the ducts.

std::vector< std::vector< Real > >	_duct_coeffs
	Coefficients in the line equations defining each duct wall.

std::vector< std::vector< unsigned int > >	_interior_channel_pin_indices
	Pin indices forming the corner of each interior channel.

std::vector< std::vector< unsigned int > >	_edge_channel_pin_indices
	Pin indices forming two of the corners of each edge channel.

std::vector< std::vector< unsigned int > >	_corner_channel_pin_indices
	Pin indices forming one of the corners of each corner channel.

std::vector< std::pair< int, int > >	_gap_indices
	Gap indices, connecting two pins or one pin and a side, ordered by global gap ID.

std::vector< std::vector< int > >	_local_to_global_gaps
	Local-to-global gap indexing, ordered by channel ID.

std::vector< std::vector< Point > >	_gap_points
	Two points on each gap, in order to compute distance-from-gap calculations.

std::vector< Point >	_gap_unit_normals
	Unit normal vectors for each gap.

unsigned int	_n_interior_gaps
	Number of gaps that touch an interior channel.

unsigned int	_n_gaps
	Total number of gaps.

std::vector< Real >	_unit_translation_x
	(unitless) x-translations to apply to move from a center point to a side of a hexagon

std::vector< Real >	_unit_translation_y
	(unitless) y-translations to apply to move from a center point to a side of a hexagon

std::vector< Point >	_gap_centers
	Center points of all the gaps.

unsigned int	_ix
	Index representing "first" coordinate of 2-D plane.

unsigned int	_iy
	Index representing "second" coordinate of 2-D plane.

Static Protected Attributes
static const Real	SIN60 = std::sqrt(3.0) / 2.0

static const Real	COS60 = 0.5

static const unsigned int	NUM_SIDES = 6
	Number of sides in a hexagon.

Private Member Functions
void	computeGapIndices ()
	Determine the global gap indices, sorted first by lower pin ID and next by higher pin ID.

void	computePinAndChannelTypes ()
	Compute the number of pins and channels and their types for the lattice.

void	computePinBundleSpacing ()
	Compute the spacing between the outer pins and the duct inner walls.

void	computeWireVolumeAndAreaPerPitch ()
	Compute the volume and surface area const occupied by the wire in one with pitch.

void	computeFlowVolumes ()
	Compute the flow volumes for each channel type.

void	computeWettedAreas ()
	Compute the wetted areas for each channel type.

void	computeHydraulicDiameters ()
	Compute the hydraulic diameters for each channel type.

void	computePinAndDuctCoordinates ()
	Compute the pin center coordinates and the duct corner coordinates.

void	computeChannelPinIndices ()
	Get the pin indices that form the corners of each channel type.

Detailed Description

Class providing various utility functions related to triangular lattices of pins enclosed in a hexagonal duct.

Notes:

the lattice is centered around an axis (X, Y, Z) going through the origin If calling the utility for a lattice that is not centered around the origin Then the point arguments must first be translated: p -= lattice_center
You should never have to rotate the point to place it in the lattice frame before calling a routine with a point argument.

Definition at line 38 of file HexagonalLatticeUtils.h.

Constructor & Destructor Documentation

◆ HexagonalLatticeUtils()

HexagonalLatticeUtils::HexagonalLatticeUtils	(	const Real	bundle_inner_flat_to_flat,
		const Real	pin_pitch,
		const Real	pin_diameter,
		const Real	wire_diameter,
		const Real	wire_pitch,
		const unsigned int	n_rings,
		const unsigned int	axis,
		const Real	rotation_around_axis = `0`
	)

Definition at line 19 of file HexagonalLatticeUtils.C.

  : _bundle_pitch(bundle_inner_flat_to_flat),
    _pin_pitch(pin_pitch),
    _pin_diameter(pin_diameter),
    _wire_diameter(wire_diameter),
    _wire_pitch(wire_pitch),
    _n_rings(n_rings),
    _axis(axis),
    _rotation_around_axis(rotation_around_axis),
    _rotation_matrix(
        RotationMatrix::rotVec2DToX(Point(std::cos(_rotation_around_axis * libMesh::pi / 180),
                                          -std::sin(_rotation_around_axis * libMesh::pi / 180),
                                          0.))),
    _bundle_side_length(hexagonSide(_bundle_pitch)),
    _pin_area(M_PI * _pin_diameter * _pin_diameter / 4.0),
    _pin_circumference(M_PI * _pin_diameter),
    _wire_area(M_PI * _wire_diameter * _wire_diameter / 4.0),
    _wire_circumference(M_PI * _wire_diameter),
    _pin_surface_area_per_pitch(M_PI * _pin_diameter * _wire_pitch),
    _pin_volume_per_pitch(_pin_area * _wire_pitch),
    _P_over_D(_pin_pitch / _pin_diameter),
    _L_over_D(_wire_pitch / _pin_diameter)
{
  auto idx = geom_utils::projectedIndices(_axis);
  _ix = idx.first;
  _iy = idx.second;
 
  // object is not tested and probably won't work if axis != 2
  if (_axis != 2)
    mooseError("The HexagonalLatticeUtils is currently limited to 'axis = 2'!");
 
  if (_pin_pitch < _pin_diameter)
    mooseError("Pin pitch of " + std::to_string(_pin_pitch) + " cannot fit pins of diameter " +
               std::to_string(_pin_diameter) + "!");
 
  if (_pin_pitch - _pin_diameter < _wire_diameter)
    mooseError("Wire diameter of " + std::to_string(_wire_diameter) +
               " cannot fit between pin-pin space of " +
               std::to_string(_pin_pitch - _pin_diameter) + "!");
 
  _unit_translation_x = {0.0, -SIN60, -SIN60, 0.0, SIN60, SIN60};
  _unit_translation_y = {1.0, COS60, -COS60, -1.0, -COS60, COS60};
 
  // Use rotation matrix on unit translation vectors
  if (rotation_around_axis != 0)
    for (const auto i : make_range(6))
    {
      const Point rotated =
          _rotation_matrix * Point(_unit_translation_x[i], _unit_translation_y[i], 0);
      _unit_translation_x[i] = rotated(0);
      _unit_translation_y[i] = rotated(1);
    }
 
  // compute number of each pin and channel and channel type (interior, edge channel)
  computePinAndChannelTypes();
 
  _corner_edge_length = (_bundle_side_length - _n_edge_channels / NUM_SIDES * _pin_pitch) / 2.0;
 
  computePinBundleSpacing();
  computeWireVolumeAndAreaPerPitch();
  computeFlowVolumes();
  computeWettedAreas();
  computeHydraulicDiameters();
  computePinAndDuctCoordinates();
  computeChannelPinIndices();
  computeGapIndices();
 
  if (_pin_bundle_spacing < _wire_diameter)
    mooseError("Specified bundle pitch " + std::to_string(_bundle_pitch) +
               " is too small to fit the given pins and wire wrap!");
}

Member Function Documentation

◆ axis()

unsigned int HexagonalLatticeUtils::axis ( ) const

inline

Get the vertical axis of the bed along which pins are aligned.

Returns: vertical axis

Definition at line 183 of file HexagonalLatticeUtils.h.

183{ return _axis; }

◆ bundlePitch()

Real HexagonalLatticeUtils::bundlePitch ( ) const

inline

Get the bundle pitch.

Returns: bundle pitch

Definition at line 213 of file HexagonalLatticeUtils.h.

213{ return _bundle_pitch; }

Referenced by TEST_F().

◆ channelCentroid()

Point HexagonalLatticeUtils::channelCentroid ( const std::vector< Point > & corners ) const

Get the centroid of a channel given the corner coordinates.

Parameters

[in] corners corner coordinates

Returns: channel centroid

Definition at line 614 of file HexagonalLatticeUtils.C.

{
  int n_pins = pins.size();
  Point centroid(0.0, 0.0, 0.0);
  for (const auto & p : pins)
    centroid += p / n_pins;
 
  return centroid;
}

◆ channelHydraulicDiameter()

Real HexagonalLatticeUtils::channelHydraulicDiameter ( const channel_type::ChannelTypeEnum & channel ) const

Get the hydraulic diameter of a channel.

Parameters

[in] channel channel type

Returns: hydraulic diameter

Definition at line 232 of file HexagonalLatticeUtils.C.

{
  switch (channel)
  {
    case channel_type::interior:
      return _interior_Dh;
    case channel_type::edge:
      return _edge_Dh;
    case channel_type::corner:
      return _corner_Dh;
    default:
      mooseError("Unhandled ChannelTypeEnum in HexagonalLattice!");
  }
}

◆ channelIndex()

unsigned int HexagonalLatticeUtils::channelIndex ( const Point & point ) const

Get the channel index given a point.

Parameters

[in] point point, must already be translated to lattice frame

Returns: channel index

Definition at line 679 of file HexagonalLatticeUtils.C.

{
  auto channel = channelType(point);
 
  switch (channel)
  {
    case channel_type::interior:
    {
      for (const auto i : make_range(_n_interior_channels))
      {
        auto corners = interiorChannelCornerCoordinates(i);
        if (geom_utils::pointInPolygon(point, corners, _axis))
          return i;
      }
      break;
    }
    case channel_type::edge:
    {
      for (const auto i : make_range(_n_edge_channels))
      {
        auto corners = edgeChannelCornerCoordinates(i);
        if (geom_utils::pointInPolygon(point, corners, _axis))
          return i + _n_interior_channels;
      }
      break;
    }
    case channel_type::corner:
    {
      for (const auto i : make_range(_n_corner_channels))
      {
        auto corners = cornerChannelCornerCoordinates(i);
        if (geom_utils::pointInPolygon(point, corners, _axis))
          return i + _n_interior_channels + _n_edge_channels;
      }
      break;
    }
    default:
      mooseError("Unhandled ChannelTypeEnum!");
  }
 
  mooseError(
      "Point (" + std::to_string(point(0)) + ", " + std::to_string(point(1)) + ", " +
      std::to_string(point(2)) +
      ") is not in any channel! This can sometimes happen "
      "due to:\n\n a) Points in the mesh actually being outside the domain specified with the "
      "HexagonalLatticeUtils.\n b) Small floating point errors - we recommend using a CONSTANT "
      "MONOMIAL variable with all related objects.\nYou can also try slightly decreasing the pin "
      "diameter and/or "
      "increasing the bundle pitch.");
}

Referenced by gapIndex(), gapIndexAndDistance(), TEST_F(), and TEST_F().

◆ channelSpecificSurfaceArea()

Real HexagonalLatticeUtils::channelSpecificSurfaceArea ( const channel_type::ChannelTypeEnum & channel ) const

Get the specific surface area of a channel.

Parameters

[in] channel channel type

Returns: flow volume per wire pitch

Definition at line 215 of file HexagonalLatticeUtils.C.

{
  switch (channel)
  {
    case channel_type::interior:
      return _interior_wetted_area / _interior_volume;
    case channel_type::edge:
      return _edge_wetted_area / _edge_volume;
    case channel_type::corner:
      return _corner_wetted_area / _corner_volume;
    default:
      mooseError("Unhandled ChannelTypeEnum in HexagonalLattice!");
  }
}

◆ channelType()

channel_type::ChannelTypeEnum HexagonalLatticeUtils::channelType ( const Point & p ) const

Get the channel type (interior, edge, corner) given a point.

Parameters

[in] p point, must already be translated to lattice frame

Returns: channel type

Definition at line 195 of file HexagonalLatticeUtils.C.

{
  const Real distance_to_wall = minDuctWallDistance(p);
 
  if (distance_to_wall > _pin_bundle_spacing + pinRadius())
    return channel_type::interior;
 
  // the point is in a corner channel if the right triangle formed by the point,
  // the corner, and the duct wall has a wall length less than the wall length
  // of a corner channel
  const Real distance_to_corner = minDuctCornerDistance(p);
  Real l = std::sqrt(distance_to_corner * distance_to_corner - distance_to_wall * distance_to_wall);
 
  if (l < _corner_edge_length)
    return channel_type::corner;
  else
    return channel_type::edge;
}

Referenced by channelIndex(), and TEST_F().

◆ closestPinIndex()

unsigned int HexagonalLatticeUtils::closestPinIndex ( const Point & point ) const

Get the closest pin index given a point outside the lattice.

Parameters

[in] point point, must already be translated to lattice frame

Returns: pin index

Definition at line 650 of file HexagonalLatticeUtils.C.

{
  // If within the lattice, you must consider all pins. If outside, outer ring suffices
  unsigned int start_index = 0;
  if (!insideLattice(point))
    start_index = firstPinInRing(_n_rings);
 
  // Classic minimum search. If more performance is required for a large lattice we may consider
  // using a KD-Tree instead or checking which ring the point is part of before examining each pin
  auto min_distance = std::numeric_limits<Real>::max();
  unsigned int index_min = 0;
  for (unsigned int i = start_index; i < _n_pins; ++i)
  {
    const auto & center = _pin_centers[i];
    Real dx = center(_ix) - point(_ix);
    Real dy = center(_iy) - point(_iy);
    Real distance_from_pin = std::sqrt(dx * dx + dy * dy);
 
    if (distance_from_pin < min_distance)
    {
      min_distance = distance_from_pin;
      index_min = i;
    }
  }
 
  return index_min;
}

◆ computeChannelPinIndices()

void HexagonalLatticeUtils::computeChannelPinIndices ( )

private

Get the pin indices that form the corners of each channel type.

Definition at line 465 of file HexagonalLatticeUtils.C.

{
  _interior_channel_pin_indices.resize(_n_interior_channels);
  _edge_channel_pin_indices.resize(_n_edge_channels);
  _corner_channel_pin_indices.resize(_n_corner_channels);
 
  // 3 pins per interior channel
  for (auto & i : _interior_channel_pin_indices)
    i.resize(3);
 
  // 2 pins per edge channel
  for (auto & i : _edge_channel_pin_indices)
    i.resize(2);
 
  // 1 pin per corner channel
  for (auto & i : _corner_channel_pin_indices)
    i.resize(1);
 
  // for each ring of pins, and for each sector, get the "first" pin index in that ring
  std::vector<std::vector<unsigned int>> starts;
  starts.resize(_n_rings);
  for (const auto i : make_range(_n_rings))
  {
    starts[i].resize(NUM_SIDES);
    starts[i][0] = (i == 0) ? 0 : totalPins(i);
 
    for (unsigned int j = 1; j < NUM_SIDES; ++j)
      starts[i][j] = starts[i][j - 1] + i;
  }
 
  unsigned int c = 0;
  for (const auto i : make_range(_n_rings - 1))
  {
    auto channels = interiorChannels(i + 1);
    unsigned int channels_per_sector = channels / NUM_SIDES;
 
    for (const auto j : make_range(NUM_SIDES))
    {
      auto prev_inner = starts[i][j];
      auto prev_outer = starts[i + 1][j];
 
      for (const auto k : make_range(channels_per_sector))
      {
        bool downward = k % 2 == 0;
 
        if (downward)
        {
          _interior_channel_pin_indices[c][0] = prev_inner;
          _interior_channel_pin_indices[c][1] = prev_outer;
          _interior_channel_pin_indices[c][2] = ++prev_outer;
        }
        else
        {
          _interior_channel_pin_indices[c][0] = prev_outer;
          _interior_channel_pin_indices[c][1] = ++prev_inner;
          _interior_channel_pin_indices[c][2] = prev_inner - 1;
        }
 
        if (j == 5) // last sector
        {
          if (k == channels_per_sector - 1)
          {
            _interior_channel_pin_indices[c][2] = starts[i + 1][0];
            _interior_channel_pin_indices[c][0] = starts[i][0];
          }
 
          if (k == channels_per_sector - 2 && i > 0)
            _interior_channel_pin_indices[c][1] = starts[i][0];
        }
 
        c++;
      }
    }
  }
 
  for (const auto i : make_range(_n_edge_channels))
  {
    _edge_channel_pin_indices[i][0] = starts[_n_rings - 1][0] + i;
    _edge_channel_pin_indices[i][1] = _edge_channel_pin_indices[i][0] + 1;
 
    if (i == _n_edge_channels - 1)
      _edge_channel_pin_indices[i][1] = _edge_channel_pin_indices[0][0];
  }
 
  for (const auto i : make_range(_n_corner_channels))
    _corner_channel_pin_indices[i][0] =
        totalPins(_n_rings - 1) + i * (_n_edge_channels / NUM_SIDES);
}

Referenced by HexagonalLatticeUtils().

◆ computeFlowVolumes()

void HexagonalLatticeUtils::computeFlowVolumes ( )

private

Compute the flow volumes for each channel type.

Definition at line 386 of file HexagonalLatticeUtils.C.

{
  // It is assumed that in the interior and edge channels, that a wire is present half
  // of the time (because those channels contain half a pin), while in the corner channels
  // that a wire is present one sixth of the time (because those channels contain one sixth
  // of a pin).
  Real rod_volume_per_pitch = _pin_volume_per_pitch + _wire_volume_per_pitch;
 
  Real l = _pin_bundle_spacing + pinRadius();
 
  _interior_volume = triangleVolume(_pin_pitch);
  _edge_volume = _pin_pitch * l * _wire_pitch;
  _corner_volume = l * _corner_edge_length * _wire_pitch;
 
  _interior_flow_volume = _interior_volume - 0.5 * rod_volume_per_pitch;
  _edge_flow_volume = _edge_volume - 0.5 * rod_volume_per_pitch;
  _corner_flow_volume = _corner_volume - rod_volume_per_pitch / 6.0;
 
  _flow_volume = hexagonVolume(_bundle_pitch) - _n_pins * rod_volume_per_pitch;
}

Referenced by HexagonalLatticeUtils().

◆ computeGapIndices()

void HexagonalLatticeUtils::computeGapIndices ( )

private

Determine the global gap indices, sorted first by lower pin ID and next by higher pin ID.

Definition at line 785 of file HexagonalLatticeUtils.C.

{
  std::set<std::pair<int, int>> indices;
  for (const auto & pins : _interior_channel_pin_indices)
  {
    std::pair<int, int> gap0 = {std::min(pins[0], pins[1]), std::max(pins[0], pins[1])};
    std::pair<int, int> gap1 = {std::min(pins[0], pins[2]), std::max(pins[0], pins[2])};
    std::pair<int, int> gap2 = {std::min(pins[2], pins[1]), std::max(pins[2], pins[1])};
 
    indices.insert(gap0);
    indices.insert(gap1);
    indices.insert(gap2);
  }
 
  for (const auto & it : indices)
    _gap_indices.push_back({it.first, it.second});
 
  _n_interior_gaps = _gap_indices.size();
 
  // add the gaps along the peripheral channels; -1 indicates side 1, -2 indicates side 2,
  // and so on
  int n_edge_gaps = _n_rings;
  int pin = totalPins(_n_rings - 1);
  for (const auto i : make_range(NUM_SIDES))
  {
    for (const auto j : make_range(_n_rings))
      _gap_indices.push_back({pin + j, -(i + 1)});
 
    pin += n_edge_gaps - 1;
  }
 
  // fix the last gap to use the first pin
  _gap_indices.back() = {totalPins(_n_rings - 1), -int(NUM_SIDES)};
  _n_gaps = _gap_indices.size();
 
  // for each channel, determine which gaps are on that channel to find the local-to-global
  // indexing
  for (const auto & pins : _interior_channel_pin_indices)
  {
    std::pair<int, int> gap0 = {std::min(pins[0], pins[1]), std::max(pins[0], pins[1])};
    std::pair<int, int> gap1 = {std::min(pins[1], pins[2]), std::max(pins[1], pins[2])};
    std::pair<int, int> gap2 = {std::min(pins[2], pins[0]), std::max(pins[2], pins[0])};
 
    int loc_gap0 = globalGapIndex(gap0);
    int loc_gap1 = globalGapIndex(gap1);
    int loc_gap2 = globalGapIndex(gap2);
    _local_to_global_gaps.push_back({loc_gap0, loc_gap1, loc_gap2});
  }
 
  int gap = _gap_indices.size() - _n_rings * NUM_SIDES;
  for (const auto i : make_range(_n_edge_channels))
  {
    const auto & pins = _edge_channel_pin_indices[i];
    std::pair<int, int> gap0 = {std::min(pins[0], pins[1]), std::max(pins[0], pins[1])};
    int loc_gap0 = globalGapIndex(gap0);
    _local_to_global_gaps.push_back({loc_gap0, gap + 1, gap});
 
    if ((i + 1) % (_n_rings - 1) == 0)
      gap += 2;
    else
      gap += 1;
  }
 
  int n_interior_gaps = _gap_indices.size() - _n_rings * NUM_SIDES - 1;
  n_edge_gaps = _n_rings * NUM_SIDES;
  _local_to_global_gaps.push_back({n_interior_gaps + n_edge_gaps, n_interior_gaps + 1});
  gap = n_interior_gaps + _n_rings;
  for (unsigned int i = 1; i < _n_corner_channels; ++i)
  {
    _local_to_global_gaps.push_back({gap, gap + 1});
    gap += _n_rings;
  }
 
  _gap_points.resize(_n_gaps);
 
  // For each gap, get two points on the gap
  for (const auto i : make_range(_n_interior_gaps))
  {
    const auto & pins = _gap_indices[i];
    Point pt1(_pin_centers[pins.first]);
    Point pt2(_pin_centers[pins.second]);
    _gap_centers.push_back(0.5 * (pt2 + pt1));
 
    _gap_points[i] = {pt1, pt2};
 
    // for the last gap in the ring, we need to swap the ordering of pins
    if (lastGapInRing(i))
    {
      Point tmp = pt1;
      pt1 = pt2;
      pt2 = tmp;
    }
 
    _gap_unit_normals.push_back(geom_utils::projectedUnitNormal(pt1, pt2, _axis));
  }
 
  Real d = _pin_bundle_spacing + pinRadius();
  for (unsigned int i = _n_interior_gaps; i < _n_gaps; ++i)
  {
    const auto & pins = _gap_indices[i];
    int side = std::abs(pins.second) - 1;
 
    const auto & pt1 = _pin_centers[pins.first];
    const Point pt2 =
        pt1 + Point(d * _unit_translation_x[side], d * _unit_translation_y[side], 0.0);
    _gap_centers.push_back(0.5 * (pt2 + pt1));
 
    _gap_points[i] = {pt1, pt2};
 
    _gap_unit_normals.push_back(geom_utils::projectedUnitNormal(pt1, pt2, _axis));
  }
}

Referenced by HexagonalLatticeUtils().

◆ computeHydraulicDiameters()

void HexagonalLatticeUtils::computeHydraulicDiameters ( )

private

Compute the hydraulic diameters for each channel type.

Definition at line 374 of file HexagonalLatticeUtils.C.

{
  // Because the hydraulic diameter should be different for a bundle with an
  // infinite wire pitch vs. a finite wire pitch (because finite = more wire spooled in),
  // we compute hydraulic diameters based on volumes and areas.
  _interior_Dh = 4 * _interior_flow_volume / _interior_wetted_area;
  _edge_Dh = 4 * _edge_flow_volume / _edge_wetted_area;
  _corner_Dh = 4 * _corner_flow_volume / _corner_wetted_area;
  _Dh = 4 * _flow_volume / _wetted_area;
}

Referenced by HexagonalLatticeUtils().

◆ computePinAndChannelTypes()

void HexagonalLatticeUtils::computePinAndChannelTypes ( )

private

Compute the number of pins and channels and their types for the lattice.

Definition at line 414 of file HexagonalLatticeUtils.C.

{
  _n_pins = 0;
  for (unsigned int i = _n_rings; i > 0; --i)
    _n_pins += pins(i);
 
  // the one-ring case
  _n_interior_pins = _n_pins;
  _n_edge_pins = 0;
  _n_corner_pins = 0;
 
  _n_corner_channels = NUM_SIDES;
  _n_edge_channels = 0;
  _n_interior_channels = 0;
 
  if (_n_rings > 1)
  {
    _n_corner_pins = NUM_SIDES;
    _n_edge_pins = (_n_rings - 2) * NUM_SIDES;
    _n_interior_pins -= _n_corner_pins + _n_edge_pins;
 
    _n_edge_channels = _n_edge_pins + NUM_SIDES;
 
    for (unsigned int i = 1; i < _n_rings; ++i)
      _n_interior_channels += interiorChannels(i);
  }
 
  _n_channels = _n_interior_channels + _n_edge_channels + _n_corner_channels;
}

Referenced by HexagonalLatticeUtils().

◆ computePinAndDuctCoordinates()

void HexagonalLatticeUtils::computePinAndDuctCoordinates ( )

private

Compute the pin center coordinates and the duct corner coordinates.

Compute the x, y, z coordinates of the pincells based on a bundle centered on (0, 0, 0) and with pins aligned in the z direction. Also compute the corner coordinates of the ducts

Definition at line 271 of file HexagonalLatticeUtils.C.

{
  Real corner_shiftx[] = {COS60, -COS60, -1, -COS60, COS60, 1};
  Real corner_shifty[] = {SIN60, SIN60, 0, -SIN60, -SIN60, 0};
 
  Real edge_shiftx[] = {-1, -COS60, COS60, 1, COS60, -COS60};
  Real edge_shifty[] = {0, -SIN60, -SIN60, 0, SIN60, SIN60};
 
  // Use rotation matrix on shift vectors
  if (_rotation_around_axis != 0)
    for (const auto i : make_range(6))
    {
      Point rotated = _rotation_matrix * Point(corner_shiftx[i], corner_shifty[i], 0);
      corner_shiftx[i] = rotated(0);
      corner_shifty[i] = rotated(1);
      rotated = _rotation_matrix * Point(edge_shiftx[i], edge_shifty[i], 0);
      edge_shiftx[i] = rotated(0);
      edge_shifty[i] = rotated(1);
    }
 
  // compute coordinates of the pin centers relative to the bundle's center
  Point center(0, 0, 0);
  _pin_centers.push_back(center);
 
  for (unsigned int i = 2; i <= _n_rings; ++i)
  {
    auto n_total_in_ring = pins(i);
    auto increment = i - 1;
 
    unsigned int d = 0;
 
    for (const auto j : make_range(n_total_in_ring))
    {
      unsigned int side = j / increment;
 
      if (d == increment)
        d = 0;
 
      Point center = geom_utils::projectPoint(corner_shiftx[side] * _pin_pitch * (i - 1),
                                              corner_shifty[side] * _pin_pitch * (i - 1),
                                              _axis);
 
      // additional shift for the edge sides
      if (d != 0)
      {
        center(_ix) += edge_shiftx[side] * _pin_pitch * d;
        center(_iy) += edge_shifty[side] * _pin_pitch * d;
      }
 
      _pin_centers.push_back(center);
 
      d += 1;
    }
  }
 
  // compute corners of the hexagonal prisms that enclose each pin
  _pin_centered_corner_coordinates.resize(_n_pins);
  auto side = hexagonSide(_pin_pitch);
  for (const auto pin : make_range(_n_pins))
  {
    for (const auto i : make_range(NUM_SIDES))
    {
      Point translation = geom_utils::projectPoint(
          _unit_translation_x[i] * side, _unit_translation_y[i] * side, _axis);
 
      _pin_centered_corner_coordinates[pin].push_back(translation + _pin_centers[pin]);
    }
  }
 
  // compute coordinates of duct corners relative to the bundle's center
  Real l = _bundle_side_length;
  for (const auto i : make_range(NUM_SIDES))
  {
    Point corner = geom_utils::projectPoint(corner_shiftx[i] * l, corner_shifty[i] * l, _axis);
    _duct_corners.push_back(corner);
  }
 
  // compute the equations (a*x + b*y + c) defining each duct wall
  for (const auto i : make_range(NUM_SIDES))
  {
    auto c = i;
    unsigned int n = i == 5 ? 0 : i + 1;
    Real slope = (_duct_corners[n](_iy) - _duct_corners[c](_iy)) /
                 (_duct_corners[n](_ix) - _duct_corners[c](_ix));
    std::vector<Real> coeffs = {-slope, 1.0, slope * _duct_corners[c](_ix) - _duct_corners[c](_iy)};
    _duct_coeffs.push_back(coeffs);
  }
}

Referenced by HexagonalLatticeUtils().

◆ computePinBundleSpacing()

void HexagonalLatticeUtils::computePinBundleSpacing ( )

private

Compute the spacing between the outer pins and the duct inner walls.

Definition at line 445 of file HexagonalLatticeUtils.C.

{
  // hexagonal flat-to-flat that *just* encloses the pins (NOT including the wire)
  Real pin_h = 2.0 * (_n_rings - 1) * triangleHeight(_pin_pitch) + _pin_diameter;
 
  _pin_bundle_spacing = (_bundle_pitch - pin_h) / 2.0;
}

Referenced by HexagonalLatticeUtils().

◆ computeWettedAreas()

void HexagonalLatticeUtils::computeWettedAreas ( )

private

Compute the wetted areas for each channel type.

Definition at line 361 of file HexagonalLatticeUtils.C.

{
  Real rod_area_per_pitch = _pin_surface_area_per_pitch + _wire_surface_area_per_pitch;
 
  _interior_wetted_area = 0.5 * rod_area_per_pitch;
  _edge_wetted_area = 0.5 * rod_area_per_pitch + _pin_pitch * _wire_pitch;
 
  Real h = (_bundle_side_length - _n_edge_channels / NUM_SIDES * _pin_pitch) / 2.0;
  _corner_wetted_area = rod_area_per_pitch / 6.0 + 2 * h * _wire_pitch;
  _wetted_area = _n_pins * rod_area_per_pitch + 6.0 * _bundle_side_length * _wire_pitch;
}

Referenced by HexagonalLatticeUtils().

◆ computeWireVolumeAndAreaPerPitch()

void HexagonalLatticeUtils::computeWireVolumeAndAreaPerPitch ( )

private

Compute the volume and surface area const occupied by the wire in one with pitch.

Definition at line 454 of file HexagonalLatticeUtils.C.

{
  unsigned int n_wire_coils = 1;
  Real wire_length_per_coil =
      std::sqrt(_wire_pitch * _wire_pitch + std::pow(M_PI * (_pin_diameter + _wire_diameter), 2.0));
  Real wire_length = wire_length_per_coil * n_wire_coils;
  _wire_volume_per_pitch = _wire_area * wire_length;
  _wire_surface_area_per_pitch = _wire_circumference * wire_length;
}

Referenced by HexagonalLatticeUtils().

◆ cornerChannelCornerCoordinates()

const std::vector< Point > HexagonalLatticeUtils::cornerChannelCornerCoordinates ( const unsigned int corner_channel_id ) const

Get the corner coordinates of a corner channel given an ID (relative to the start of the corner channels)

Parameters

[in] corner_channel_id ID of corner channel

Returns: corner coordinates of channel

Definition at line 591 of file HexagonalLatticeUtils.C.

{
  std::vector<Point> corners;
 
  auto pin_indices = _corner_channel_pin_indices[corner_channel_id];
  const Point & pin = _pin_centers[pin_indices[0]];
  corners.push_back(pin);
 
  Real d = pinBundleSpacing() + pinRadius();
 
  unsigned int side1 = corner_channel_id == 0 ? NUM_SIDES - 1 : corner_channel_id - 1;
  unsigned int side2 = corner_channel_id;
 
  corners.push_back(pin +
                    Point(d * _unit_translation_x[side1], d * _unit_translation_y[side1], 0.0));
  corners.push_back(_duct_corners[corner_channel_id]);
  corners.push_back(pin +
                    Point(d * _unit_translation_x[side2], d * _unit_translation_y[side2], 0.0));
 
  return corners;
}

Referenced by channelIndex().

◆ cornerChannelPinIndices()

const std::vector< std::vector< unsigned int > > & HexagonalLatticeUtils::cornerChannelPinIndices ( ) const

inline

Get the pin indices forming one of the corners of all corner channels.

Returns: pin indices forming one of the corners of all corner channels

Definition at line 517 of file HexagonalLatticeUtils.h.

  {
    return _corner_channel_pin_indices;
  }

Referenced by TEST_F().

◆ cornerEdgeLength()

Real HexagonalLatticeUtils::cornerEdgeLength ( ) const

inline

Get half the distance of the duct that a corner channel is in contact with.

Returns: half the duct length that a corner channel is in contact with

Definition at line 396 of file HexagonalLatticeUtils.h.

396{ return _corner_edge_length; }

◆ cornerFlowVolume()

Real HexagonalLatticeUtils::cornerFlowVolume ( ) const

inline

Get the flow volume of an corner channel per wire pitch.

Returns: flow volume of corner channel

Definition at line 315 of file HexagonalLatticeUtils.h.

315{ return _corner_flow_volume; }

Referenced by TEST_F().

◆ cornerHydraulicDiameter()

Real HexagonalLatticeUtils::cornerHydraulicDiameter ( ) const

inline

Get the hydraulic diameter of a corner channel.

Returns: hydraulic diameter of a corner channel

Definition at line 267 of file HexagonalLatticeUtils.h.

267{ return _corner_Dh; }

◆ cornerVolume()

Real HexagonalLatticeUtils::cornerVolume ( ) const

inline

Get the total volume of an corner channel per wire pitch.

Returns: total volume of corner channel

Definition at line 333 of file HexagonalLatticeUtils.h.

333{ return _corner_volume; }

◆ cornerWettedArea()

Real HexagonalLatticeUtils::cornerWettedArea ( ) const

inline

Get the wetted area of a corner channel per wire pitch.

Returns: wetted area of corner channel

Definition at line 291 of file HexagonalLatticeUtils.h.

291{ return _corner_wetted_area; }

Referenced by TEST_F().

◆ distanceFromGap()

Real HexagonalLatticeUtils::distanceFromGap	(	const Point &	pt,
		const unsigned int	gap_index
	)		const

Distance from a point and a gap.

Parameters

[in]	pt	point, must already be translated to lattice frame
[in]	gap_index	gap index @ return distance from gap

Definition at line 912 of file HexagonalLatticeUtils.C.

{
  auto p = _gap_points[gap_index];
  return geom_utils::projectedDistanceFromLine(pt, p[0], p[1], _axis);
}

Referenced by gapIndex(), and gapIndexAndDistance().

◆ edgeChannelCornerCoordinates()

const std::vector< Point > HexagonalLatticeUtils::edgeChannelCornerCoordinates ( const unsigned int edge_channel_id ) const

Get the corner coordinates of an edge channel given an ID (relative to the start of the edge channels)

Parameters

[in] edge_channel_id ID of edge channel

Returns: corner coordinates of channel

Definition at line 567 of file HexagonalLatticeUtils.C.

{
  std::vector<Point> corners;
 
  auto pin_indices = _edge_channel_pin_indices[edge_channel_id];
 
  const Point & pin1 = _pin_centers[pin_indices[0]];
  const Point & pin2 = _pin_centers[pin_indices[1]];
 
  Real d = pinBundleSpacing() + pinRadius();
 
  corners.push_back(pin1);
  corners.push_back(pin2);
 
  unsigned int sector = edge_channel_id / (_n_rings - 1);
  corners.push_back(pin2 +
                    Point(d * _unit_translation_x[sector], d * _unit_translation_y[sector], 0.0));
  corners.push_back(pin1 +
                    Point(d * _unit_translation_x[sector], d * _unit_translation_y[sector], 0.0));
 
  return corners;
}

Referenced by channelIndex().

◆ edgeChannelPinIndices()

const std::vector< std::vector< unsigned int > > & HexagonalLatticeUtils::edgeChannelPinIndices ( ) const

inline

Get the pin indices forming two of the corners of all edge channels.

Returns: pin indices forming two of the corners of all edge channels

Definition at line 508 of file HexagonalLatticeUtils.h.

  {
    return _edge_channel_pin_indices;
  }

Referenced by TEST_F().

◆ edgeFlowVolume()

Real HexagonalLatticeUtils::edgeFlowVolume ( ) const

inline

Get the flow volume of an edge channel per wire pitch.

Returns: flow volume of edge channel

Definition at line 309 of file HexagonalLatticeUtils.h.

309{ return _edge_flow_volume; }

Referenced by TEST_F().

◆ edgeHydraulicDiameter()

Real HexagonalLatticeUtils::edgeHydraulicDiameter ( ) const

inline

Get the hydraulic diameter of an edge channel.

Returns: hydraulic diameter of an edge channel

Definition at line 261 of file HexagonalLatticeUtils.h.

261{ return _edge_Dh; }

◆ edgeVolume()

Real HexagonalLatticeUtils::edgeVolume ( ) const

inline

Get the total volume of an edge channel per wire pitch.

Returns: total volume of edge channel

Definition at line 327 of file HexagonalLatticeUtils.h.

327{ return _edge_volume; }

◆ edgeWettedArea()

Real HexagonalLatticeUtils::edgeWettedArea ( ) const

inline

Get the wetted area of an edge channel per wire pitch.

Returns: wetted area of edge channel

Definition at line 285 of file HexagonalLatticeUtils.h.

285{ return _edge_wetted_area; }

Referenced by TEST_F().

◆ firstPinInRing()

unsigned int HexagonalLatticeUtils::firstPinInRing ( const unsigned int ring ) const

Get the index of the "first" pin in a ring.

Parameters

[in] ring ring index

Returns: first pin

Definition at line 962 of file HexagonalLatticeUtils.C.

{
  mooseAssert(ring > 0, "Ring indexing starts at 1");
  if (ring == 1)
    return 0;
  else
    return totalPins(ring - 1);
}

Referenced by closestPinIndex(), get2DInputPatternIndex(), lastGapInRing(), and TEST_F().

◆ flowVolume()

Real HexagonalLatticeUtils::flowVolume ( ) const

inline

Get the flow volume of the bundle per wire pitch.

Returns: flow volume of bundle

Definition at line 339 of file HexagonalLatticeUtils.h.

339{ return _flow_volume; }

Referenced by TEST_F().

◆ gapCenters()

const std::vector< Point > & HexagonalLatticeUtils::gapCenters ( ) const

inline

Get the center coordinates of the gaps.

Returns: gap center coordinates

Definition at line 159 of file HexagonalLatticeUtils.h.

159{ return _gap_centers; }

◆ gapIndex()

unsigned int HexagonalLatticeUtils::gapIndex ( const Point & point ) const

Get the index for the gap closest to the point.

Parameters

[in] point point, must already be translated to lattice frame

Returns: index of closest gap

Definition at line 919 of file HexagonalLatticeUtils.C.

{
  const auto & channel_index = channelIndex(point);
  const auto & gap_indices = _local_to_global_gaps[channel_index];
 
  Real distance = std::numeric_limits<Real>::max();
  unsigned int index = 0;
  for (const auto i : index_range(gap_indices))
  {
    Real distance_from_gap = distanceFromGap(point, gap_indices[i]);
 
    if (distance_from_gap < distance)
    {
      distance = distance_from_gap;
      index = gap_indices[i];
    }
  }
 
  return index;
}

Referenced by TEST_F().

◆ gapIndexAndDistance()

void HexagonalLatticeUtils::gapIndexAndDistance	(	const Point &	point,
		unsigned int &	index,
		Real &	distance
	)		const

Get the gap index and distance to that gap for a given point.

Parameters

[in]	point	point, must already be translated to lattice frame
[out]	index	index of closest gap
[out]	distance	distance to closest gap

Definition at line 941 of file HexagonalLatticeUtils.C.

{
  const auto & channel_index = channelIndex(point);
  const auto & gap_indices = _local_to_global_gaps[channel_index];
 
  distance = std::numeric_limits<Real>::max();
  for (const auto i : index_range(gap_indices))
  {
    Real distance_from_gap = distanceFromGap(point, gap_indices[i]);
 
    if (distance_from_gap < distance)
    {
      distance = distance_from_gap;
      index = gap_indices[i];
    }
  }
}

◆ gapIndices()

const std::vector< std::pair< int, int > > & HexagonalLatticeUtils::gapIndices ( ) const

inline

Get the pin and side indices on each gap.

Returns: pin and side indices on each gap

Definition at line 526 of file HexagonalLatticeUtils.h.

526{ return _gap_indices; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ gapUnitNormals()

const std::vector< Point > & HexagonalLatticeUtils::gapUnitNormals ( ) const

inline

Get the unit normals for all of the gaps.

Returns: gap unit normals

Definition at line 119 of file HexagonalLatticeUtils.h.

119{ return _gap_unit_normals; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ get2DInputPatternIndex()

void HexagonalLatticeUtils::get2DInputPatternIndex	(	const unsigned int	pin_index,
		unsigned int &	row_index,
		unsigned int &	within_row_index
	)		const

Conversion from lattice pin indexing to the 2D input file index.

The indexing matches like this. Note that you have a 30 degree rotation between the 2D input and the positions output 2 1 3 0 6 4 5

Parameters

pin_index	index of the pin in the utility ring-wise indexing
row_index	row index (from the top) in the 2D input
within_row_index	index within the row

Definition at line 745 of file HexagonalLatticeUtils.C.

{
 
  // First compute the ring on which the pin is
  const auto ring_index = ringIndex(pin_index);
  row_index = _n_rings - ring_index;
  within_row_index = _n_rings - 1;
 
  const auto n_pin_sectors = pins(ring_index) / 6;
  // Loop around the center until we reach the pin_index
  // We start on the diagonal at the top
 
  for (const auto local_i : make_range(pin_index - firstPinInRing(ring_index)))
  {
    if (local_i < n_pin_sectors)
      within_row_index--;
    else if (local_i < 3 * n_pin_sectors)
      row_index++;
    else if (local_i < 4 * n_pin_sectors)
      within_row_index++;
    else if (local_i < 5 * n_pin_sectors)
    {
      row_index--;
      within_row_index++;
    }
    else
    {
      row_index--;
      within_row_index--;
    }
  }
 
  // Underflow (row_index is invalid_uint) will also fail this assert
  mooseAssert(row_index < 2 * _n_rings - 1, "Inverse indexing failed");
  mooseAssert(within_row_index < 2 * _n_rings - 1, "Inverse indexing failed");
}

◆ globalGapIndex()

unsigned int HexagonalLatticeUtils::globalGapIndex ( const std::pair< int, int > & local_gap ) const

protected

Get the global gap index from the local gap index.

Parameters

[in] local_gap local gap for a channel

Returns: global gap index

Definition at line 899 of file HexagonalLatticeUtils.C.

{
  for (const auto i : index_range(_gap_indices))
  {
    const auto gap = _gap_indices[i];
    if (gap.first == local_gap.first && gap.second == local_gap.second)
      return i;
  }
 
  mooseError("Failed to find local gap in global gap array!");
}

◆ heightToDiameter()

Real HexagonalLatticeUtils::heightToDiameter ( ) const

inline

Get the (wire) axial pitch-to-diameter ratio.

Returns: wire axial pitch-to-diameter ratio

Definition at line 177 of file HexagonalLatticeUtils.h.

177{ return _L_over_D; }

◆ hexagonArea()

Real HexagonalLatticeUtils::hexagonArea ( const Real pitch ) const

Get the area of a hexagon with given flat-to-flat distance (pitch)

Parameters

[in] pitch flat-to-flat distance

Returns: hexagon area

Definition at line 145 of file HexagonalLatticeUtils.C.

{
  Real side = hexagonSide(pitch);
  return 3 * SIN60 * side * side;
}

Referenced by hexagonVolume().

◆ hexagonPitch()

Real HexagonalLatticeUtils::hexagonPitch ( const Real volume ) const

Get the pitch of a hexagonal prism based on its per-wire-pitch volume.

Parameters

[in] volume volume

Returns: pitch

Definition at line 158 of file HexagonalLatticeUtils.C.

{
  Real area = volume / _wire_pitch;
  return std::sqrt(area / SIN60);
}

◆ hexagonSide()

Real HexagonalLatticeUtils::hexagonSide ( const Real pitch ) const

Get the side length of a hexagon with given flat-to-flat distance (pitch)

Parameters

[in] pitch hexagon flat-to-flat distance, or pitch

Returns: side length of hexagon, to give 1/6 of the hexagon's perimeter

Definition at line 139 of file HexagonalLatticeUtils.C.

{
  return pitch / std::sqrt(3.0);
}

Referenced by computePinAndDuctCoordinates(), hexagonArea(), insideLattice(), and pinIndex().

◆ hexagonVolume()

Real HexagonalLatticeUtils::hexagonVolume ( const Real side ) const

Get the volume of a hexagonal prism per wire pitch.

Parameters

[in] side side length

Returns: hexagonal prism volume

Definition at line 152 of file HexagonalLatticeUtils.C.

{
  return hexagonArea(pitch) * _wire_pitch;
}

Referenced by computeFlowVolumes().

◆ hydraulicDiameter()

Real HexagonalLatticeUtils::hydraulicDiameter ( ) const

inline

Get the overall bundle hydraulic diameter.

Returns: hydraulic diameter

Definition at line 273 of file HexagonalLatticeUtils.h.

273{ return _Dh; }

Referenced by TEST_F().

◆ insideLattice()

bool HexagonalLatticeUtils::insideLattice ( const Point & point ) const

Whether the point is inside the lattice.

Parameters

point point being examined, must already be translated to lattice frame

Definition at line 731 of file HexagonalLatticeUtils.C.

{
  std::vector<Point> lattice_corners(6);
  auto side = hexagonSide(_bundle_pitch);
  for (const auto i : make_range(NUM_SIDES))
  {
    Point translation = geom_utils::projectPoint(
        _unit_translation_x[i] * side, _unit_translation_y[i] * side, _axis);
    lattice_corners[i] = translation;
  }
  return geom_utils::pointInPolygon(point, lattice_corners, _axis);
}

Referenced by closestPinIndex().

◆ interiorChannelCornerCoordinates()

const std::vector< Point > HexagonalLatticeUtils::interiorChannelCornerCoordinates ( const unsigned int interior_channel_id ) const

Get the corner coordinates of an interior channel given an ID (relative to the start of the interior channels)

Parameters

[in] interior_channel_id ID of interior channel

Returns: corner coordinates of channel

Definition at line 555 of file HexagonalLatticeUtils.C.

{
  std::vector<Point> corners;
  auto pin_indices = _interior_channel_pin_indices[interior_channel_id];
  for (const auto & pin : pin_indices)
    corners.push_back(_pin_centers[pin]);
 
  return corners;
}

Referenced by channelIndex().

◆ interiorChannelPinIndices()

const std::vector< std::vector< unsigned int > > & HexagonalLatticeUtils::interiorChannelPinIndices ( ) const

inline

Get the pin indices forming the corners of all interior channels.

Returns: pin indices forming the corners of all interior channels

Definition at line 499 of file HexagonalLatticeUtils.h.

  {
    return _interior_channel_pin_indices;
  }

Referenced by TEST_F().

◆ interiorChannels()

unsigned int HexagonalLatticeUtils::interiorChannels ( const unsigned int ring )

Get the number of interior channels between ring and ring - 1 (0 indexing)

Parameters

[in] ring ring number (relative to 0 indexing)

Returns: number of interior channels

Definition at line 408 of file HexagonalLatticeUtils.C.

{
  return (ring * 2 - 1) * NUM_SIDES;
}

Referenced by computeChannelPinIndices(), and computePinAndChannelTypes().

◆ interiorFlowVolume()

Real HexagonalLatticeUtils::interiorFlowVolume ( ) const

inline

Get the flow volume of an interior channel per wire pitch.

Returns: flow volume of interior channel

Definition at line 303 of file HexagonalLatticeUtils.h.

303{ return _interior_flow_volume; }

Referenced by TEST_F().

◆ interiorHydraulicDiameter()

Real HexagonalLatticeUtils::interiorHydraulicDiameter ( ) const

inline

Get the hydraulic diameter of an interior channel.

Returns: hydraulic diameter of an interior channel

Definition at line 255 of file HexagonalLatticeUtils.h.

255{ return _interior_Dh; }

◆ interiorVolume()

Real HexagonalLatticeUtils::interiorVolume ( ) const

inline

Get the total volume of an interior channel per wire pitch.

Returns: total volume of interior channel

Definition at line 321 of file HexagonalLatticeUtils.h.

321{ return _interior_volume; }

◆ interiorWettedArea()

Real HexagonalLatticeUtils::interiorWettedArea ( ) const

inline

Get the wetted area of an interior channel per wire pitch.

Returns: wetted area of interior channel

Definition at line 279 of file HexagonalLatticeUtils.h.

279{ return _interior_wetted_area; }

Referenced by TEST_F().

◆ lastGapInRing()

bool HexagonalLatticeUtils::lastGapInRing ( const unsigned int gap_index ) const

Whether this gap is the "last" in the ring, i.e.

connecting the first and last pins of the ring

Parameters

[in] gap_index gap index

Returns: whether this gap is the last in the ring

Definition at line 993 of file HexagonalLatticeUtils.C.

{
  if (gap_index >= _n_interior_gaps)
    return false;
 
  const auto & pins = _gap_indices[gap_index];
 
  for (unsigned int i = 2; i <= _n_rings; ++i)
  {
    bool one_is_first_pin = false;
    bool one_is_last_pin = false;
 
    int first_pin = firstPinInRing(i);
    int last_pin = lastPinInRing(i);
 
    if (pins.first == first_pin || pins.second == first_pin)
      one_is_first_pin = true;
 
    if (pins.first == last_pin || pins.second == last_pin)
      one_is_last_pin = true;
 
    if (one_is_first_pin && one_is_last_pin)
      return true;
  }
 
  return false;
}

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ lastPinInRing()

unsigned int HexagonalLatticeUtils::lastPinInRing ( const unsigned int ring ) const

Get the index of the "last" pin in a ring.

Parameters

[in] ring ring index

Returns: last pin

Definition at line 972 of file HexagonalLatticeUtils.C.

{
  mooseAssert(ring > 0, "Ring indexing starts at 1");
  if (ring == 1)
    return 0;
  else
    return totalPins(ring) - 1;
}

Referenced by lastGapInRing(), ringIndex(), and TEST_F().

◆ localToGlobalGaps()

const std::vector< std::vector< int > > & HexagonalLatticeUtils::localToGlobalGaps ( ) const

inline

For each subchannel, get the indices of the gaps that touch that subchannel.

Returns: indices of gaps touch each channel

Definition at line 532 of file HexagonalLatticeUtils.h.

532{ return _local_to_global_gaps; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ minDuctCornerDistance()

Real HexagonalLatticeUtils::minDuctCornerDistance ( const Point & p ) const

Get the minimum distance from a point to the duct corners.

Parameters

[in] p point, must already be translated to lattice frame

Returns: distance to duct corner

Definition at line 265 of file HexagonalLatticeUtils.C.

{
  return geom_utils::minDistanceToPoints(p, _duct_corners, _axis);
}

Referenced by channelType().

◆ minDuctWallDistance()

Real HexagonalLatticeUtils::minDuctWallDistance ( const Point & p ) const

Get the minimum distance from a point to the duct inner surface.

Parameters

[in] p point, must already be translated to lattice frame

Returns: distance to duct

Definition at line 248 of file HexagonalLatticeUtils.C.

{
  Real distance = std::numeric_limits<Real>::max();
  for (const auto i : make_range(NUM_SIDES))
  {
    Real a = _duct_coeffs[i][0];
    Real b = _duct_coeffs[i][1];
    Real c = _duct_coeffs[i][2];
 
    Real d = std::abs(a * p(_ix) + b * p(_iy) + c) / std::sqrt(a * a + b * b);
    distance = std::min(d, distance);
  }
 
  return distance;
}

Referenced by channelType().

◆ nChannels()

unsigned int HexagonalLatticeUtils::nChannels ( ) const

inline

Get the total number of channels.

Returns: number of channels

Definition at line 363 of file HexagonalLatticeUtils.h.

363{ return _n_channels; }

Referenced by TEST_F().

◆ nCornerChannels()

unsigned int HexagonalLatticeUtils::nCornerChannels ( ) const

inline

Get the number of corner channels.

Returns: number of corner channels

Definition at line 357 of file HexagonalLatticeUtils.h.

357{ return _n_corner_channels; }

Referenced by TEST_F(), and TEST_F().

◆ nCornerPins()

unsigned int HexagonalLatticeUtils::nCornerPins ( ) const

inline

Get the number of corner pins.

Returns: number of corner pins

Definition at line 243 of file HexagonalLatticeUtils.h.

243{ return _n_corner_pins; }

Referenced by TEST_F().

◆ nEdgeChannels()

unsigned int HexagonalLatticeUtils::nEdgeChannels ( ) const

inline

Get the number of edge channels.

Returns: number of edge channels

Definition at line 351 of file HexagonalLatticeUtils.h.

351{ return _n_edge_channels; }

Referenced by TEST_F(), and TEST_F().

◆ nEdgePins()

unsigned int HexagonalLatticeUtils::nEdgePins ( ) const

inline

Get the number of edge pins.

Returns: number of edge pins

Definition at line 237 of file HexagonalLatticeUtils.h.

237{ return _n_edge_pins; }

Referenced by TEST_F().

◆ nGaps()

unsigned int HexagonalLatticeUtils::nGaps ( ) const

inline

Get the number of gaps.

Returns: number of gaps

Definition at line 165 of file HexagonalLatticeUtils.h.

165{ return _n_gaps; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ nInteriorChannels()

unsigned int HexagonalLatticeUtils::nInteriorChannels ( ) const

inline

Get the number of interior channels.

Returns: number of interior channels

Definition at line 345 of file HexagonalLatticeUtils.h.

345{ return _n_interior_channels; }

Referenced by TEST_F(), and TEST_F().

◆ nInteriorGaps()

unsigned int HexagonalLatticeUtils::nInteriorGaps ( ) const

inline

Get the number of gaps that touch an interior channel.

Returns: number of gaps touching an interior channel

Definition at line 153 of file HexagonalLatticeUtils.h.

153{ return _n_interior_gaps; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ nInteriorPins()

unsigned int HexagonalLatticeUtils::nInteriorPins ( ) const

inline

Get the number of interior pins.

Returns: number of interior pins

Definition at line 231 of file HexagonalLatticeUtils.h.

231{ return _n_interior_pins; }

Referenced by TEST_F().

◆ nPins()

unsigned int HexagonalLatticeUtils::nPins ( ) const

inline

Get the total number of pins for the lattice.

Returns: total number of pins

Definition at line 249 of file HexagonalLatticeUtils.h.

249{ return _n_pins; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ pinBundleSpacing()

Real HexagonalLatticeUtils::pinBundleSpacing ( ) const

inline

Get the distance between the outermost pins and the duct walls.

Returns: pin-bundle spacing

Definition at line 369 of file HexagonalLatticeUtils.h.

369{ return _pin_bundle_spacing; }

Referenced by cornerChannelCornerCoordinates(), edgeChannelCornerCoordinates(), and TEST_F().

◆ pinCenteredCornerCoordinates()

const std::vector< std::vector< Point > > & HexagonalLatticeUtils::pinCenteredCornerCoordinates ( ) const

inline

Get the corner coordinates of a hexagon surrounding each pin.

Returns: pin center coordinates

Definition at line 381 of file HexagonalLatticeUtils.h.

  {
    return _pin_centered_corner_coordinates;
  }

Referenced by TEST_F().

◆ pinCenters()

const std::vector< Point > & HexagonalLatticeUtils::pinCenters ( ) const

inline

Get the center coordinates of the pins.

Returns: pin center coordinates

Definition at line 375 of file HexagonalLatticeUtils.h.

375{ return _pin_centers; }

Referenced by TEST_F(), TEST_F(), and TEST_F().

◆ pinDiameter()

Real HexagonalLatticeUtils::pinDiameter ( ) const

inline

Get the pin diameter.

Returns: pin diameter

Definition at line 189 of file HexagonalLatticeUtils.h.

189{ return _pin_diameter; }

Referenced by TEST_F().

◆ pinIndex()

unsigned int HexagonalLatticeUtils::pinIndex ( const Point & point ) const

Get the pin index given a point.

The pin index is for the entire hexagon around the pin

Parameters

[in] point point, must already be translated to lattice frame

Returns: pin index

Definition at line 625 of file HexagonalLatticeUtils.C.

{
  auto side = hexagonSide(_pin_pitch);
 
  for (const auto i : make_range(_n_pins))
  {
    const auto & center = _pin_centers[i];
    Real dx = center(_ix) - point(_ix);
    Real dy = center(_iy) - point(_iy);
    Real distance_from_pin = std::sqrt(dx * dx + dy * dy);
 
    // if we're outside the circumference of the hexagon, we're certain not
    // within the hexagon for this pin
    if (distance_from_pin > side)
      continue;
 
    auto corners = _pin_centered_corner_coordinates[i];
    if (geom_utils::pointInPolygon(point, corners, _axis))
      return i;
  }
 
  return _n_pins;
}

Referenced by TEST_F().

◆ pinPitch()

Real HexagonalLatticeUtils::pinPitch ( ) const

inline

Get the pin pitch.

Returns: pin pitch

Definition at line 207 of file HexagonalLatticeUtils.h.

207{ return _pin_pitch; }

Referenced by TEST_F().

◆ pinRadius()

Real HexagonalLatticeUtils::pinRadius ( ) const

Get the pin outer radius.

Returns: pin outer radius

Definition at line 189 of file HexagonalLatticeUtils.C.

{
  return _pin_diameter / 2.0;
}

Referenced by channelType(), computeFlowVolumes(), cornerChannelCornerCoordinates(), edgeChannelCornerCoordinates(), and TEST_F().

◆ pins()

unsigned int HexagonalLatticeUtils::pins ( const unsigned int n ) const

Get the number of pins in a given ring.

Parameters

[in] n ring number, beginning from 1

Returns: number of pins in the specified ring

Definition at line 99 of file HexagonalLatticeUtils.C.

{
  if (n <= 0)
    return 0;
  else if (n == 1)
    return 1;
  else
    return NUM_SIDES * (n - 1);
}

Referenced by channelCentroid(), computeGapIndices(), computePinAndChannelTypes(), computePinAndDuctCoordinates(), get2DInputPatternIndex(), lastGapInRing(), rings(), TEST_F(), and totalPins().

◆ pinSurfaceAreaPerPitch()

Real HexagonalLatticeUtils::pinSurfaceAreaPerPitch ( ) const

inline

Get the pin surface area per wire pitch.

Returns: pin surface area per wire pitch

Definition at line 390 of file HexagonalLatticeUtils.h.

390{ return _pin_surface_area_per_pitch; }

◆ pinVolumePerPitch()

Real HexagonalLatticeUtils::pinVolumePerPitch ( ) const

inline

Get the pin volume per pitch.

Returns: pin volume per pitch

Definition at line 219 of file HexagonalLatticeUtils.h.

219{ return _pin_volume_per_pitch; }

◆ pitchToDiameter()

Real HexagonalLatticeUtils::pitchToDiameter ( ) const

inline

Get the (pin) pitch-to-diameter ratio.

Returns: pin pitch-to-diameter ratio

Definition at line 171 of file HexagonalLatticeUtils.h.

171{ return _P_over_D; }

◆ ringIndex()

unsigned int HexagonalLatticeUtils::ringIndex ( const unsigned int pin ) const

Get the index of the ring for a certain pin index.

Parameters

[in] pin pin index

Returns: ring index

Definition at line 982 of file HexagonalLatticeUtils.C.

{
  for (const auto i : make_range(_n_rings))
  {
    if (pin <= lastPinInRing(i + 1))
      return i + 1;
  }
  mooseError("Should not reach here. Pin index: ", pin, " for ", _n_rings, " rings.");
}

Referenced by get2DInputPatternIndex().

◆ rings()

unsigned int HexagonalLatticeUtils::rings ( const unsigned int n ) const

Get the number of rings for a specified number of pins.

Parameters

[in] n number of pins

Returns: number of hexagonal rings

Definition at line 120 of file HexagonalLatticeUtils.C.

{
  auto remaining = n;
  unsigned int i = 0;
 
  while (remaining > 0)
  {
    i += 1;
    remaining -= pins(i);
  }
 
  if (n != totalPins(i))
    mooseError("Number of pins " + std::to_string(n) +
               " not evenly divisible in a hexagonal lattice!");
 
  return i;
}

Referenced by TEST_F().

◆ sideTranslationX()

Real HexagonalLatticeUtils::sideTranslationX ( const unsigned int side ) const

inline

Get the unit vector translation to move a center point to a duct wall.

Parameters

[in] side duct side

Returns: x-component translation

Definition at line 78 of file HexagonalLatticeUtils.h.

78{ return _unit_translation_x[side]; }

◆ sideTranslationY()

Real HexagonalLatticeUtils::sideTranslationY ( const unsigned int side ) const

inline

Get the unit vector translation to move a center point to a duct wall.

Parameters

[in] side duct side

Returns: y-component translation

Definition at line 85 of file HexagonalLatticeUtils.h.

85{ return _unit_translation_y[side]; }

◆ totalPins()

unsigned int HexagonalLatticeUtils::totalPins ( const unsigned int n ) const

Get the total number of pins for all rings.

Parameters

[in] n number of total rings, beginning from 1

Returns: total number of pins

Definition at line 110 of file HexagonalLatticeUtils.C.

{
  unsigned int total = 0;
  for (unsigned int i = 1; i <= n; ++i)
    total += pins(i);
 
  return total;
}

Referenced by computeChannelPinIndices(), firstPinInRing(), lastPinInRing(), and rings().

◆ triangleArea()

Real HexagonalLatticeUtils::triangleArea ( const Real side ) const

Get the area of an equilateral triangle with given side length.

Parameters

[in] side side length

Returns: triangle area

Definition at line 165 of file HexagonalLatticeUtils.C.

{
  return 0.5 * triangleHeight(side) * side;
}

Referenced by triangleVolume().

◆ triangleHeight()

Real HexagonalLatticeUtils::triangleHeight ( const Real side ) const

Get the height of an equilateral triangle with given side length.

Parameters

[in] side side length

Returns: triangle height

Definition at line 171 of file HexagonalLatticeUtils.C.

{
  return SIN60 * side;
}

Referenced by computePinBundleSpacing(), and triangleArea().

◆ triangleSide()

Real HexagonalLatticeUtils::triangleSide ( const Real height ) const

Get the side of an equilateral triangle with given height.

Parameters

[in] height triangle height

Returns: triangle side

Definition at line 177 of file HexagonalLatticeUtils.C.

{
  return height / SIN60;
}

◆ triangleVolume()

Real HexagonalLatticeUtils::triangleVolume ( const Real side ) const

Get the volume of an equilateral triangle prism per wire pitch.

Parameters

[in] side side length

Returns: triangle prism volume

Definition at line 183 of file HexagonalLatticeUtils.C.

{
  return triangleArea(side) * _wire_pitch;
}

Referenced by computeFlowVolumes().

◆ wettedArea()

Real HexagonalLatticeUtils::wettedArea ( ) const

inline

Get the wetted area of entire bundle per wire pitch.

Returns: wetted area of bundle

Definition at line 297 of file HexagonalLatticeUtils.h.

297{ return _wetted_area; }

Referenced by TEST_F().

◆ wireDiameter()

Real HexagonalLatticeUtils::wireDiameter ( ) const

inline

Get the wire diameter.

Returns: wire diameter

Definition at line 201 of file HexagonalLatticeUtils.h.

201{ return _wire_diameter; }

Referenced by TEST_F().

◆ wirePitch()

Real HexagonalLatticeUtils::wirePitch ( ) const

inline

Get the wire pitch.

Returns: wire pitch

Definition at line 195 of file HexagonalLatticeUtils.h.

195{ return _wire_pitch; }

Referenced by TEST_F().

◆ wireVolumePerPitch()

Real HexagonalLatticeUtils::wireVolumePerPitch ( ) const

inline

Get the wire volume per pitch.

Returns: wire volume per pitch

Definition at line 225 of file HexagonalLatticeUtils.h.

225{ return _wire_volume_per_pitch; }

Member Data Documentation

◆ _axis

const unsigned int HexagonalLatticeUtils::_axis

protected

Vertical axis of the bundle along which the pins are aligned.

Definition at line 635 of file HexagonalLatticeUtils.h.

Referenced by axis(), channelIndex(), computePinAndDuctCoordinates(), distanceFromGap(), HexagonalLatticeUtils(), insideLattice(), minDuctCornerDistance(), and pinIndex().

◆ _bundle_pitch

const Real HexagonalLatticeUtils::_bundle_pitch

protected

Bundle pitch (distance across bundle measured flat-to-flat on the inside of the duct)

Definition at line 617 of file HexagonalLatticeUtils.h.

Referenced by bundlePitch(), computeFlowVolumes(), computePinBundleSpacing(), HexagonalLatticeUtils(), and insideLattice().

◆ _bundle_side_length

const Real HexagonalLatticeUtils::_bundle_side_length

protected

Side length of duct.

Definition at line 644 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), computeWettedAreas(), and HexagonalLatticeUtils().

◆ _corner_channel_pin_indices

std::vector<std::vector<unsigned int> > HexagonalLatticeUtils::_corner_channel_pin_indices

protected

Pin indices forming one of the corners of each corner channel.

Definition at line 775 of file HexagonalLatticeUtils.h.

Referenced by computeChannelPinIndices(), cornerChannelCornerCoordinates(), and cornerChannelPinIndices().

◆ _corner_Dh

Real HexagonalLatticeUtils::_corner_Dh

protected

Hydraulic diameter of corner channel.

Definition at line 713 of file HexagonalLatticeUtils.h.

Referenced by channelHydraulicDiameter(), computeHydraulicDiameters(), and cornerHydraulicDiameter().

◆ _corner_edge_length

Real HexagonalLatticeUtils::_corner_edge_length

protected

Half the distance for which a corner channel is in contact with the duct.

Definition at line 704 of file HexagonalLatticeUtils.h.

Referenced by channelType(), computeFlowVolumes(), cornerEdgeLength(), and HexagonalLatticeUtils().

◆ _corner_flow_volume

Real HexagonalLatticeUtils::_corner_flow_volume

protected

Flow volume of a corner channel per wire pitch.

Definition at line 725 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeHydraulicDiameters(), and cornerFlowVolume().

◆ _corner_volume

Real HexagonalLatticeUtils::_corner_volume

protected

Total volume of a corner channel per wire pitch.

Definition at line 734 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeFlowVolumes(), and cornerVolume().

◆ _corner_wetted_area

Real HexagonalLatticeUtils::_corner_wetted_area

protected

Wetted area of a corner channel per wire pitch.

Definition at line 746 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeHydraulicDiameters(), computeWettedAreas(), and cornerWettedArea().

◆ _Dh

Real HexagonalLatticeUtils::_Dh

protected

Bundle-wide hydraulic diameter.

Definition at line 716 of file HexagonalLatticeUtils.h.

Referenced by computeHydraulicDiameters(), and hydraulicDiameter().

◆ _duct_coeffs

std::vector<std::vector<Real> > HexagonalLatticeUtils::_duct_coeffs

protected

Coefficients in the line equations defining each duct wall.

Coefficients \(a\), \(b\), and \(c\) in equation \(ax+by+c=0\) that defines each wall of the duct.

Definition at line 766 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), and minDuctWallDistance().

◆ _duct_corners

std::vector<Point> HexagonalLatticeUtils::_duct_corners

protected

Six corner coordinates for the ducts.

Definition at line 758 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), cornerChannelCornerCoordinates(), and minDuctCornerDistance().

◆ _edge_channel_pin_indices

std::vector<std::vector<unsigned int> > HexagonalLatticeUtils::_edge_channel_pin_indices

protected

Pin indices forming two of the corners of each edge channel.

Definition at line 772 of file HexagonalLatticeUtils.h.

Referenced by computeChannelPinIndices(), edgeChannelCornerCoordinates(), and edgeChannelPinIndices().

◆ _edge_Dh

Real HexagonalLatticeUtils::_edge_Dh

protected

Hydraulic diameter of edge channel.

Definition at line 710 of file HexagonalLatticeUtils.h.

Referenced by channelHydraulicDiameter(), computeHydraulicDiameters(), and edgeHydraulicDiameter().

◆ _edge_flow_volume

Real HexagonalLatticeUtils::_edge_flow_volume

protected

Flow volume of an edge channel per wire pitch.

Definition at line 722 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeHydraulicDiameters(), and edgeFlowVolume().

◆ _edge_volume

Real HexagonalLatticeUtils::_edge_volume

protected

Total volume of an edge channel per wire pitch.

Definition at line 731 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeFlowVolumes(), and edgeVolume().

◆ _edge_wetted_area

Real HexagonalLatticeUtils::_edge_wetted_area

protected

Wetted area of an edge channel per wire pitch.

Definition at line 743 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeHydraulicDiameters(), computeWettedAreas(), and edgeWettedArea().

◆ _flow_volume

Real HexagonalLatticeUtils::_flow_volume

protected

Bundle-wide flow volume per wire pitch.

Definition at line 737 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeHydraulicDiameters(), and flowVolume().

◆ _gap_centers

std::vector<Point> HexagonalLatticeUtils::_gap_centers

protected

Center points of all the gaps.

Definition at line 809 of file HexagonalLatticeUtils.h.

Referenced by gapCenters().

◆ _gap_indices

std::vector<std::pair<int, int> > HexagonalLatticeUtils::_gap_indices

protected

Gap indices, connecting two pins or one pin and a side, ordered by global gap ID.

Definition at line 778 of file HexagonalLatticeUtils.h.

Referenced by computeGapIndices(), gapIndices(), globalGapIndex(), and lastGapInRing().

◆ _gap_points

std::vector<std::vector<Point> > HexagonalLatticeUtils::_gap_points

protected

Two points on each gap, in order to compute distance-from-gap calculations.

Definition at line 784 of file HexagonalLatticeUtils.h.

Referenced by distanceFromGap().

◆ _gap_unit_normals

std::vector<Point> HexagonalLatticeUtils::_gap_unit_normals

protected

Unit normal vectors for each gap.

Definition at line 787 of file HexagonalLatticeUtils.h.

Referenced by gapUnitNormals().

◆ _interior_channel_pin_indices

std::vector<std::vector<unsigned int> > HexagonalLatticeUtils::_interior_channel_pin_indices

protected

Pin indices forming the corner of each interior channel.

Definition at line 769 of file HexagonalLatticeUtils.h.

Referenced by computeChannelPinIndices(), computeGapIndices(), interiorChannelCornerCoordinates(), and interiorChannelPinIndices().

◆ _interior_Dh

Real HexagonalLatticeUtils::_interior_Dh

protected

Hydraulic diameter of interior channel.

Definition at line 707 of file HexagonalLatticeUtils.h.

Referenced by channelHydraulicDiameter(), computeHydraulicDiameters(), and interiorHydraulicDiameter().

◆ _interior_flow_volume

Real HexagonalLatticeUtils::_interior_flow_volume

protected

Flow volume of an interior channel per wire pitch.

Definition at line 719 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeHydraulicDiameters(), and interiorFlowVolume().

◆ _interior_volume

Real HexagonalLatticeUtils::_interior_volume

protected

Total volume of an interior channel per wire pitch.

Definition at line 728 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeFlowVolumes(), and interiorVolume().

◆ _interior_wetted_area

Real HexagonalLatticeUtils::_interior_wetted_area

protected

Wetted area of an interior channel per wire pitch.

Definition at line 740 of file HexagonalLatticeUtils.h.

Referenced by channelSpecificSurfaceArea(), computeHydraulicDiameters(), computeWettedAreas(), and interiorWettedArea().

◆ _ix

unsigned int HexagonalLatticeUtils::_ix

protected

Index representing "first" coordinate of 2-D plane.

Definition at line 812 of file HexagonalLatticeUtils.h.

Referenced by closestPinIndex(), computePinAndDuctCoordinates(), HexagonalLatticeUtils(), minDuctWallDistance(), and pinIndex().

◆ _iy

unsigned int HexagonalLatticeUtils::_iy

protected

Index representing "second" coordinate of 2-D plane.

Definition at line 815 of file HexagonalLatticeUtils.h.

Referenced by closestPinIndex(), computePinAndDuctCoordinates(), HexagonalLatticeUtils(), minDuctWallDistance(), and pinIndex().

◆ _L_over_D

const Real HexagonalLatticeUtils::_L_over_D

protected

Wire axial lead length to diameter ratio.

Definition at line 668 of file HexagonalLatticeUtils.h.

Referenced by heightToDiameter().

◆ _local_to_global_gaps

std::vector<std::vector<int> > HexagonalLatticeUtils::_local_to_global_gaps

protected

Local-to-global gap indexing, ordered by channel ID.

Definition at line 781 of file HexagonalLatticeUtils.h.

Referenced by gapIndex(), gapIndexAndDistance(), and localToGlobalGaps().

◆ _n_channels

unsigned int HexagonalLatticeUtils::_n_channels

protected

Total number of channels.

Definition at line 692 of file HexagonalLatticeUtils.h.

Referenced by computePinAndChannelTypes(), and nChannels().

◆ _n_corner_channels

unsigned int HexagonalLatticeUtils::_n_corner_channels

protected

Total number of corner channels.

Definition at line 701 of file HexagonalLatticeUtils.h.

Referenced by channelIndex(), computeChannelPinIndices(), computePinAndChannelTypes(), and nCornerChannels().

◆ _n_corner_pins

unsigned int HexagonalLatticeUtils::_n_corner_pins

protected

Number of corner pins.

Definition at line 689 of file HexagonalLatticeUtils.h.

Referenced by computePinAndChannelTypes(), and nCornerPins().

◆ _n_edge_channels

unsigned int HexagonalLatticeUtils::_n_edge_channels

protected

Total number of edge channels.

Definition at line 698 of file HexagonalLatticeUtils.h.

Referenced by channelIndex(), computeChannelPinIndices(), computePinAndChannelTypes(), computeWettedAreas(), HexagonalLatticeUtils(), and nEdgeChannels().

◆ _n_edge_pins

unsigned int HexagonalLatticeUtils::_n_edge_pins

protected

Number of edge pins.

Definition at line 686 of file HexagonalLatticeUtils.h.

Referenced by computePinAndChannelTypes(), and nEdgePins().

◆ _n_gaps

unsigned int HexagonalLatticeUtils::_n_gaps

protected

Total number of gaps.

Definition at line 793 of file HexagonalLatticeUtils.h.

Referenced by nGaps().

◆ _n_interior_channels

unsigned int HexagonalLatticeUtils::_n_interior_channels

protected

Total number of interior channels.

Definition at line 695 of file HexagonalLatticeUtils.h.

Referenced by channelIndex(), computeChannelPinIndices(), computePinAndChannelTypes(), and nInteriorChannels().

◆ _n_interior_gaps

unsigned int HexagonalLatticeUtils::_n_interior_gaps

protected

Number of gaps that touch an interior channel.

Definition at line 790 of file HexagonalLatticeUtils.h.

Referenced by lastGapInRing(), and nInteriorGaps().

◆ _n_interior_pins

unsigned int HexagonalLatticeUtils::_n_interior_pins

protected

Number of interior pins.

Definition at line 683 of file HexagonalLatticeUtils.h.

Referenced by computePinAndChannelTypes(), and nInteriorPins().

◆ _n_pins

unsigned int HexagonalLatticeUtils::_n_pins

protected

Total number of pins.

Definition at line 680 of file HexagonalLatticeUtils.h.

Referenced by closestPinIndex(), computeFlowVolumes(), computePinAndChannelTypes(), computePinAndDuctCoordinates(), computeWettedAreas(), nPins(), and pinIndex().

◆ _n_rings

const unsigned int HexagonalLatticeUtils::_n_rings

protected

Total number of rings of pins.

Definition at line 632 of file HexagonalLatticeUtils.h.

Referenced by closestPinIndex(), computeChannelPinIndices(), computePinAndChannelTypes(), computePinAndDuctCoordinates(), computePinBundleSpacing(), edgeChannelCornerCoordinates(), get2DInputPatternIndex(), lastGapInRing(), and ringIndex().

◆ _P_over_D

const Real HexagonalLatticeUtils::_P_over_D

protected

Pitch-to-diameter ratio.

Definition at line 665 of file HexagonalLatticeUtils.h.

Referenced by pitchToDiameter().

◆ _pin_area

const Real HexagonalLatticeUtils::_pin_area

protected

Pin cross-sectional area.

Definition at line 647 of file HexagonalLatticeUtils.h.

◆ _pin_bundle_spacing

Real HexagonalLatticeUtils::_pin_bundle_spacing

protected

Spacing between the duct inner wall and the pin surface.

Definition at line 674 of file HexagonalLatticeUtils.h.

Referenced by channelType(), computeFlowVolumes(), computePinBundleSpacing(), HexagonalLatticeUtils(), and pinBundleSpacing().

◆ _pin_centered_corner_coordinates

std::vector<std::vector<Point> > HexagonalLatticeUtils::_pin_centered_corner_coordinates

protected

Corner coordinates of a hexagon surrounding each pin.

Definition at line 755 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), pinCenteredCornerCoordinates(), and pinIndex().

◆ _pin_centers

std::vector<Point> HexagonalLatticeUtils::_pin_centers

protected

Pin center coordinates.

Definition at line 752 of file HexagonalLatticeUtils.h.

Referenced by closestPinIndex(), computePinAndDuctCoordinates(), cornerChannelCornerCoordinates(), edgeChannelCornerCoordinates(), interiorChannelCornerCoordinates(), pinCenters(), and pinIndex().

◆ _pin_circumference

const Real HexagonalLatticeUtils::_pin_circumference

protected

Pin circumference.

Definition at line 650 of file HexagonalLatticeUtils.h.

◆ _pin_diameter

const Real HexagonalLatticeUtils::_pin_diameter

protected

Pin diameter.

Definition at line 623 of file HexagonalLatticeUtils.h.

Referenced by computePinBundleSpacing(), computeWireVolumeAndAreaPerPitch(), HexagonalLatticeUtils(), pinDiameter(), and pinRadius().

◆ _pin_pitch

const Real HexagonalLatticeUtils::_pin_pitch

protected

Pin pitch.

Definition at line 620 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computePinAndDuctCoordinates(), computePinBundleSpacing(), computeWettedAreas(), HexagonalLatticeUtils(), pinIndex(), and pinPitch().

◆ _pin_surface_area_per_pitch

const Real HexagonalLatticeUtils::_pin_surface_area_per_pitch

protected

Pin surface area per wire pitch.

Definition at line 659 of file HexagonalLatticeUtils.h.

Referenced by computeWettedAreas(), and pinSurfaceAreaPerPitch().

◆ _pin_volume_per_pitch

const Real HexagonalLatticeUtils::_pin_volume_per_pitch

protected

Single-pin volume per wire pitch.

Definition at line 662 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), and pinVolumePerPitch().

◆ _rotation_around_axis

const Real HexagonalLatticeUtils::_rotation_around_axis

protected

Rotation around the axis to apply to the lattice.

Definition at line 638 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates().

◆ _rotation_matrix

const RealTensorValue HexagonalLatticeUtils::_rotation_matrix

protected

Rotation matrix to apply the rotation why.

Definition at line 641 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), and HexagonalLatticeUtils().

◆ _unit_translation_x

std::vector<Real> HexagonalLatticeUtils::_unit_translation_x

protected

(unitless) x-translations to apply to move from a center point to a side of a hexagon

Definition at line 803 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), cornerChannelCornerCoordinates(), edgeChannelCornerCoordinates(), HexagonalLatticeUtils(), insideLattice(), and sideTranslationX().

◆ _unit_translation_y

std::vector<Real> HexagonalLatticeUtils::_unit_translation_y

protected

(unitless) y-translations to apply to move from a center point to a side of a hexagon

Definition at line 806 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), cornerChannelCornerCoordinates(), edgeChannelCornerCoordinates(), HexagonalLatticeUtils(), insideLattice(), and sideTranslationY().

◆ _wetted_area

Real HexagonalLatticeUtils::_wetted_area

protected

Wetted area of entire bundle per wire pitch.

Definition at line 749 of file HexagonalLatticeUtils.h.

Referenced by computeHydraulicDiameters(), computeWettedAreas(), and wettedArea().

◆ _wire_area

const Real HexagonalLatticeUtils::_wire_area

protected

Wire cross-sectional area.

Definition at line 653 of file HexagonalLatticeUtils.h.

Referenced by computeWireVolumeAndAreaPerPitch().

◆ _wire_circumference

const Real HexagonalLatticeUtils::_wire_circumference

protected

Wire circumference.

Definition at line 656 of file HexagonalLatticeUtils.h.

Referenced by computeWireVolumeAndAreaPerPitch().

◆ _wire_diameter

const Real HexagonalLatticeUtils::_wire_diameter

protected

Wire diameter.

Definition at line 626 of file HexagonalLatticeUtils.h.

Referenced by computeWireVolumeAndAreaPerPitch(), HexagonalLatticeUtils(), and wireDiameter().

◆ _wire_pitch

const Real HexagonalLatticeUtils::_wire_pitch

protected

Wire pitch.

Definition at line 629 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeWettedAreas(), computeWireVolumeAndAreaPerPitch(), hexagonPitch(), hexagonVolume(), triangleVolume(), and wirePitch().

◆ _wire_surface_area_per_pitch

Real HexagonalLatticeUtils::_wire_surface_area_per_pitch

protected

Wire surface area per wire pitch.

Definition at line 671 of file HexagonalLatticeUtils.h.

Referenced by computeWettedAreas(), and computeWireVolumeAndAreaPerPitch().

◆ _wire_volume_per_pitch

Real HexagonalLatticeUtils::_wire_volume_per_pitch

protected

Single-wire volume per wire pitch.

Definition at line 677 of file HexagonalLatticeUtils.h.

Referenced by computeFlowVolumes(), computeWireVolumeAndAreaPerPitch(), and wireVolumePerPitch().

◆ COS60

const Real HexagonalLatticeUtils::COS60 = 0.5

staticprotected

Definition at line 797 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), and HexagonalLatticeUtils().

◆ NUM_SIDES

const unsigned int HexagonalLatticeUtils::NUM_SIDES = 6

staticprotected

Number of sides in a hexagon.

Definition at line 800 of file HexagonalLatticeUtils.h.

Referenced by computeChannelPinIndices(), computePinAndChannelTypes(), computePinAndDuctCoordinates(), computeWettedAreas(), cornerChannelCornerCoordinates(), HexagonalLatticeUtils(), insideLattice(), interiorChannels(), minDuctWallDistance(), and pins().

◆ SIN60

const Real HexagonalLatticeUtils::SIN60 = std::sqrt(3.0) / 2.0

staticprotected

Definition at line 795 of file HexagonalLatticeUtils.h.

Referenced by computePinAndDuctCoordinates(), HexagonalLatticeUtils(), hexagonArea(), hexagonPitch(), triangleHeight(), and triangleSide().

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

reactor/include/utils/HexagonalLatticeUtils.h
reactor/src/utils/HexagonalLatticeUtils.C

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ HexagonalLatticeUtils()

Member Function Documentation

◆ axis()

◆ bundlePitch()

◆ channelCentroid()

◆ channelHydraulicDiameter()

◆ channelIndex()

◆ channelSpecificSurfaceArea()

◆ channelType()

◆ closestPinIndex()

◆ computeChannelPinIndices()

◆ computeFlowVolumes()

◆ computeGapIndices()

◆ computeHydraulicDiameters()

◆ computePinAndChannelTypes()

◆ computePinAndDuctCoordinates()

◆ computePinBundleSpacing()

◆ computeWettedAreas()

◆ computeWireVolumeAndAreaPerPitch()

◆ cornerChannelCornerCoordinates()

◆ cornerChannelPinIndices()

◆ cornerEdgeLength()

◆ cornerFlowVolume()

◆ cornerHydraulicDiameter()

◆ cornerVolume()

◆ cornerWettedArea()

◆ distanceFromGap()

◆ edgeChannelCornerCoordinates()

◆ edgeChannelPinIndices()

◆ edgeFlowVolume()

◆ edgeHydraulicDiameter()

◆ edgeVolume()

◆ edgeWettedArea()

◆ firstPinInRing()

◆ flowVolume()

◆ gapCenters()

◆ gapIndex()

◆ gapIndexAndDistance()

◆ gapIndices()

◆ gapUnitNormals()

◆ get2DInputPatternIndex()

◆ globalGapIndex()

◆ heightToDiameter()

◆ hexagonArea()

◆ hexagonPitch()

◆ hexagonSide()

◆ hexagonVolume()

◆ hydraulicDiameter()

◆ insideLattice()

◆ interiorChannelCornerCoordinates()

◆ interiorChannelPinIndices()

◆ interiorChannels()

◆ interiorFlowVolume()

◆ interiorHydraulicDiameter()

◆ interiorVolume()

◆ interiorWettedArea()

◆ lastGapInRing()

◆ lastPinInRing()

◆ localToGlobalGaps()

◆ minDuctCornerDistance()

◆ minDuctWallDistance()

◆ nChannels()

◆ nCornerChannels()

◆ nCornerPins()

◆ nEdgeChannels()

◆ nEdgePins()

◆ nGaps()

◆ nInteriorChannels()

◆ nInteriorGaps()

◆ nInteriorPins()

◆ nPins()

◆ pinBundleSpacing()

◆ pinCenteredCornerCoordinates()