Rotating 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 = [
+        "pointsCornerDpa",
+        "cornerFastFlux",
+        "pointsCornerFastFluxFr",
+        "pointsCornerDpaRate",
+        "pointsEdgeFastFluxFr",
+        "pointsEdgeDpa",
+        "pointsEdgeDpaRate",
+    ]
+    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.