Rotate more parameters in HexBlock.rotate

armi/reactor/blocks.py

@@ -18,7 +18,7 @@
 
 Assemblies are made of blocks. Blocks are made of components.
 """
-from typing import Optional, Type, Tuple, ClassVar
+from typing import Optional, Type, Tuple, ClassVar, Callable
 import collections
 import copy
 import math
@@ -2004,7 +2004,7 @@ def setPinPowers(self, powers, powerKeySuffix=""):
  else:
  self.p.linPowByPin = self.p[powerKey]
 
- def rotate(self, rad):
+ def rotate(self, rad: float):
  """
  Rotates a block's spatially varying parameters by a specified angle in the
  counter-clockwise direction.
@@ -2027,6 +2027,11 @@ def rotate(self, rad):
  self._rotatePins(rotNum)
  self._rotateBoundaryParameters(rotNum)
  self._rotateDisplacement(rad)
+ self._rotatePinParameters(rotNum)
+
+ def _getParamsWhere(self, f: Callable[[parameters.Parameter], bool]):
+ """Produce an iterator of parameters that match a condition."""
+ return filter(f, self.pDefs)
 
  def _rotateBoundaryParameters(self, rotNum: int):
  """Rotate any parameters defined on the corners or edge of bounding hexagon.
@@ -2038,9 +2043,12 @@ def _rotateBoundaryParameters(self, rotNum: int):
  rotations have taken place.
 
  """
- names = self.p.paramDefs.atLocation(ParamLocation.CORNERS).names
- names += self.p.paramDefs.atLocation(ParamLocation.EDGES).names
- for name in names:
+ params = self._getParamsWhere(
+ lambda p: p.atLocation(ParamLocation.CORNERS)
+ or p.atLocation(ParamLocation.EDGES)
+ )
+ for param in params:
+ name = param.name
  original = self.p[name]
  if isinstance(original, (list, np.ndarray)):
  if len(original) == 6:
@@ -2167,6 +2175,25 @@ def _rotatePins(self, rotNum, justCompute=False):
 
  return rotateIndexLookup
 
+ def _rotatePinParameters(self, rotNum: int):
+ params = self._getParamsWhere(lambda pd: pd.atLocation(ParamLocation.CHILDREN))
+ for param in params:
+ name = param.name
+ original = self.p[name]
+ if isinstance(original, (list, np.ndarray)):
+ try:
+ newData = hexagon.rotateHexCellData(original, rotNum)
+ self.p[name] = newData
+ except Exception as ee:
+ raise RuntimeError(
+ f"Failed to rotate parameter {name=} with data={original}"
+ ) from ee
+ # Doesn't make sense to rotate scalar data nor data that isn't defined
+ elif isinstance(original, (int, float)) or original is None:
+ pass
+ else:
+ raise TypeError(f"{name=} :: {original=}")
+
  def verifyBlockDims(self):
  """Perform some checks on this type of block before it is assembled."""
  try:

armi/reactor/parameters/parameterDefinitions.py

@@ -55,38 +55,33 @@
 
 
 class Category:
- """
- A "namespace" for storing parameter categories.
-
- Notes
- -----
- * `cumulative` parameters are accumulated over many time steps
- * `pinQuantities` parameters are defined on the pin level within a block
- * `multiGroupQuantities` parameters have group dependence (often a 1D numpy array)
- * `fluxQuantities` parameters are related to neutron or gamma flux
- * `neutronics` parameters are calculated in a neutronics global flux solve
- * `gamma` parameters are calculated in a fixed-source gamma solve
- * `detailedAxialExpansion` parameters are marked as such so that they are mapped from the
- uniform mesh back to the non-uniform mesh
- * `reactivity coefficients` parameters are related to reactivity coefficient or kinetics
- parameters for kinetics solutions
- * `thermal hydraulics` parameters come from a thermal hydraulics physics plugin (e.g., flow
- rates, temperatures, etc.)
- """
+ """A "namespace" for storing parameter categories."""
 
  depletion = "depletion"
+ """Parameters used in or calculated by a depletion plugin."""
  cumulative = "cumulative"
+ """Parameters are accumulated over many time steps"""
  cumulativeOverCycle = "cumulative over cycle"
+ """Parameters that are reset at beginning of cycle and accumulated over each cycle."""
  assignInBlueprints = "assign in blueprints"
+ """Parameters that should be assigned in blueprints (e.g., control rod elevation)"""
  retainOnReplacement = "retain on replacement"
  pinQuantities = "pinQuantities"
+ """Parameters are defined on the pin level within a block"""
  fluxQuantities = "fluxQuantities"
+ """Parameters are related to neutron or gamma flux"""
  multiGroupQuantities = "multi-group quantities"
+ """Parameters have group dependence (often a 1D numpy array)"""
  neutronics = "neutronics"
+ """Parameters are calculated in a neutronics global flux solve"""
  gamma = "gamma"
+ """Parameters are calculated in a fixed-source gamma solve"""
  detailedAxialExpansion = "detailedAxialExpansion"
+ """Parameters that are mapped from the uniform mesh back to the non-uniform mesh"""
  reactivityCoefficients = "reactivity coefficients"
+ """Parameters are related to reactivity coefficient or kinetics parameters for kinetics solutions"""
  thermalHydraulics = "thermal hydraulics"
+ """Parameters related to thermal hydraulics"""
 
 
 class ParamLocation(enum.Flag):
@@ -100,7 +95,8 @@ class ParamLocation(enum.Flag):
  CORNERS = 32
  EDGES = 64
  VOLUME_INTEGRATED = 128
- CHILDREN = 256 # on some child of a composite, like a pin
+ CHILDREN = 256
+ """Parameter defined on some child of a composite, like a pin."""
 
 
 class NoDefault:
@@ -417,7 +413,7 @@ def restoreBackup(self, paramsToApply):
  else:
  self._backup, self.assigned = self._backup
 
- def atLocation(self, loc):
+ def atLocation(self, loc: ParamLocation) -> bool:
  """True if parameter is defined at location."""
  return self.location and self.location & loc
 
@@ -438,7 +434,7 @@ class ParameterDefinitionCollection:
  __slots__ = ("_paramDefs", "_paramDefDict", "_representedTypes", "_locked")
 
  def __init__(self):
- self._paramDefs = list()
+ self._paramDefs: list[Parameter] = list()
  self._paramDefDict = dict()
  self._representedTypes = set()
  self._locked = False
@@ -505,14 +501,14 @@ def extend(self, other):
  for pd in other:
  self.add(pd)
 
- def inCategory(self, categoryName):
+ def inCategory(self, categoryName: str):
  """
  Create a :py:class:`ParameterDefinitionCollection` that contains definitions that are in a
  specific category.
  """
  return self._filter(lambda pd: categoryName in pd.categories)
 
- def atLocation(self, paramLoc):
+ def atLocation(self, paramLoc: ParamLocation):
  """
  Make a param definition collection with all defs defined at a specific location.
 
@@ -571,22 +567,22 @@ def byNameAndCollectionType(self, name, collectionType):
  return self._paramDefDict[name, collectionType]
 
  @property
- def categories(self):
+ def categories(self) -> set[str]:
  """Get the categories of all the :py:class:`~Parameter` instances within this collection."""
  categories = set()
  for paramDef in self:
  categories |= paramDef.categories
  return categories
 
  @property
- def names(self):
+ def names(self) -> list[str]:
  return [pd.name for pd in self]
 
  def lock(self):
  self._locked = True
 
  @property
- def locked(self):
+ def locked(self) -> bool:
  return self._locked
 
  def toWriteToDB(self, assignedMask: Optional[int] = None):

armi/reactor/tests/test_blocks.py

@@ -36,7 +36,7 @@
 from armi.reactor.flags import Flags
 from armi.reactor.tests.test_assemblies import makeTestAssembly
 from armi.tests import ISOAA_PATH, TEST_ROOT
-from armi.utils import hexagon, units
+from armi.utils import hexagon, units, iterables
 from armi.utils.units import MOLES_PER_CC_TO_ATOMS_PER_BARN_CM
 
 NUM_PINS_IN_TEST_BLOCK = 217
@@ -1447,37 +1447,6 @@ def test_106_getAreaFractions(self):
 
  self.assertAlmostEqual(sum(fracs.values()), sum([a for c, a in cur]))
 
- def test_rotatePins(self):
- b = self.block
- b.setRotationNum(0)
- index = b._rotatePins(0, justCompute=True)
- self.assertEqual(b.getRotationNum(), 0)
- self.assertEqual(index[5], 5)
- self.assertEqual(index[2], 2) # pin 1 is center and never rotates.
-
- index = b._rotatePins(1)
- self.assertEqual(b.getRotationNum(), 1)
- self.assertEqual(index[2], 3)
- self.assertEqual(b.p.pinLocation[1], 3)
-
- index = b._rotatePins(1)
- self.assertEqual(b.getRotationNum(), 2)
- self.assertEqual(index[2], 4)
- self.assertEqual(b.p.pinLocation[1], 4)
-
- index = b._rotatePins(2)
- index = b._rotatePins(4) # over-rotate to check modulus
- self.assertEqual(b.getRotationNum(), 2)
- self.assertEqual(index[2], 4)
- self.assertEqual(index[6], 2)
- self.assertEqual(b.p.pinLocation[1], 4)
- self.assertEqual(b.p.pinLocation[5], 2)
-
- self.assertRaises(ValueError, b._rotatePins, -1)
- self.assertRaises(ValueError, b._rotatePins, 10)
- self.assertRaises((ValueError, TypeError), b._rotatePins, None)
- self.assertRaises((ValueError, TypeError), b._rotatePins, "a")
-
  def test_expandElementalToIsotopics(self):
  r"""Tests the expand to elementals capability."""
  initialN = {}
@@ -1766,6 +1735,126 @@ def test_getReactionRates(self):
  )
 
 
+class BlockRotateTests(unittest.TestCase):
+ """Tests for the ability for a block to be rotated."""
+
+ BOUNDARY_PARAMS = [
+ "cornerFastFlux",
+ "pointsCornerDpa",
+ "pointsCornerDpaRate",
+ "pointsCornerFastFluxFr",
+ "pointsEdgeDpa",
+ "pointsEdgeDpaRate",
+ "pointsEdgeFastFluxFr",
+ ]
+ BOUNDARY_DATA = np.arange(6, dtype=float) * 10
+
+ PIN_PARAMS = [
+ "percentBuByPin",
+ ]
+ PIN_DATA = np.arange(NUM_PINS_IN_TEST_BLOCK, dtype=float)
+ """Scalar data for each pin.
+
+ Data at index ``i`` corresponds to pin number ``i`` in the ARMI
+ numbering scheme.
+
+ *. ``0`` is center pin, (ring, pos) = (1, 1)
+ *. ``1`` (ring, pos) = (2, 1)
+ *. ``2`` (ring, pos) = (2, 2)
+ *. ...
+ *. ``7`` (ring, pos) = (2, 6)
+ *. ``8`` (ring, pos) = (3, 1)
+ *. ...
+
+ When we rotate a HexBlock a single 60 degree rotation counter clock wise,
+ the data that was originally at (r, p) = (2, 1) is now at (r, p) = (2, 2)
+ and should be at index ``2`` in the post-rotated array.
+ """
+
+ def setUp(self):
+ self.block = loadTestBlock()
+ for name in self.BOUNDARY_PARAMS:
+ self.block.p[name] = self.BOUNDARY_DATA
+ for name in self.PIN_PARAMS:
+ self.block.p[name] = self.PIN_DATA
+
+ def test_rotatePins(self):
+ """Test rotate pins updates pin locations."""
+ b = self.block
+ b.setRotationNum(0)
+ index = b._rotatePins(0, justCompute=True)
+ self.assertEqual(b.getRotationNum(), 0)
+ self.assertEqual(index[5], 5)
+ self.assertEqual(index[2], 2) # pin 1 is center and never rotates.
+
+ index = b._rotatePins(1)
+ self.assertEqual(b.getRotationNum(), 1)
+ self.assertEqual(index[2], 3)
+ self.assertEqual(b.p.pinLocation[1], 3)
+
+ index = b._rotatePins(1)
+ self.assertEqual(b.getRotationNum(), 2)
+ self.assertEqual(index[2], 4)
+ self.assertEqual(b.p.pinLocation[1], 4)
+
+ index = b._rotatePins(2)
+ index = b._rotatePins(4) # over-rotate to check modulus
+ self.assertEqual(b.getRotationNum(), 2)
+ self.assertEqual(index[2], 4)
+ self.assertEqual(index[6], 2)
+ self.assertEqual(b.p.pinLocation[1], 4)
+ self.assertEqual(b.p.pinLocation[5], 2)
+
+ self.assertRaises(ValueError, b._rotatePins, -1)
+ self.assertRaises(ValueError, b._rotatePins, 10)
+ self.assertRaises((ValueError, TypeError), b._rotatePins, None)
+ self.assertRaises((ValueError, TypeError), b._rotatePins, "a")
+
+ def test_rotateBoundaryParameters(self):
+ """Test that boundary parameters are correctly rotated."""
+ # No rotation == no changes to data
+ self._rotateAndCompareBoundaryParams(0, self.BOUNDARY_DATA)
+ for rotNum in range(1, 6):
+ expected = iterables.pivot(self.BOUNDARY_DATA, -rotNum)
+ self._rotateAndCompareBoundaryParams(rotNum, expected)
+ # undo rotation to restore state for next test
+ self.block._rotateBoundaryParameters(6 - rotNum)
+ # Six rotations of 60 degrees puts us back to the original layout
+ self._rotateAndCompareBoundaryParams(6, self.BOUNDARY_DATA)
+
+ def _rotateAndCompareBoundaryParams(self, rotNum: int, expected: np.ndarray):
+ self.block._rotateBoundaryParameters(rotNum)
+ for name in self.BOUNDARY_PARAMS:
+ data = self.block.p[name]
+ msg = f"{name=} :: {rotNum=} :: {data=}"
+ np.testing.assert_array_equal(data, expected, err_msg=msg)
+
+ def test_rotatedPinParameters(self):
+ """Test that block parameters that reflect pin data are rotated.
+
+ Pre-rotate pin layout -> Post-rotate layout::
+
+ 2 1 1 6
+ 3 0 6 -> 2 0 5
+ 4 5 3 4
+
+ - Pre-rotate data: ``[0, 1, 2, 3, 4, 5, 6, ...]``
+ - Post-rotate data: ``[0, 6, 1, 2, 3, 4, 5, ...]``
+ """
+ self.block.rotate(math.radians(60))
+ preRotate = self.PIN_DATA
+ postRotate = self.block.p["percentBuByPin"]
+ # Center location should be the same
+ self.assertEqual(postRotate[0], preRotate[0])
+ # First ring should be shifted one index
+ self.assertEqual(postRotate[1], preRotate[6])
+ self.assertEqual(postRotate[2], preRotate[1])
+ self.assertEqual(postRotate[3], preRotate[2])
+ self.assertEqual(postRotate[4], preRotate[3])
+ self.assertEqual(postRotate[5], preRotate[4])
+ self.assertEqual(postRotate[6], preRotate[5])
+
+
 class BlockEnergyDepositionConstants(unittest.TestCase):
  """Tests the energy deposition methods.