Rotating more parameters in HexBlock.rotate

armi/physics/neutronics/parameters.py

@@ -331,7 +331,12 @@ def _getNeutronicsBlockParams():
             setter=isNumpyArray("pointsEdgeDpa"),
             units=units.DPA,
             description="displacements per atom at edges of the block",
-            categories=["cumulative", "detailedAxialExpansion", "depletion"],
+            categories=[
+                "cumulative",
+                "detailedAxialExpansion",
+                "depletion",
+                parameters.Category.rotatable,
+            ],
         )
 
         pb.defParam(
@@ -368,7 +373,12 @@ def _getNeutronicsBlockParams():
             units=units.DPA,
             description="displacements per atom at corners of the block",
             location=ParamLocation.CORNERS,
-            categories=["cumulative", "detailedAxialExpansion", "depletion"],
+            categories=[
+                "cumulative",
+                "detailedAxialExpansion",
+                "depletion",
+                parameters.Category.rotatable,
+            ],
         )
 
         pb.defParam(

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
@@ -42,7 +42,7 @@
 from armi.reactor.components.basicShapes import Hexagon, Circle
 from armi.reactor.components.complexShapes import Helix
 from armi.reactor.flags import Flags
-from armi.reactor.parameters import ParamLocation
+from armi.reactor.parameters import ParamLocation, Parameter, Category
 from armi.utils import densityTools
 from armi.utils import hexagon
 from armi.utils import iterables
@@ -2004,6 +2004,9 @@ def setPinPowers(self, powers, powerKeySuffix=""):
             else:
                 self.p.linPowByPin = self.p[powerKey]
 
+    def _paramsWhere(self, f: Callable[[Parameter], bool]):
+        return filter(f, self.p.paramDefs)
+
     def rotate(self, rad):
         """
         Rotates a block's spatially varying parameters by a specified angle in the
@@ -2022,6 +2025,22 @@ def rotate(self, rad):
             in 60-degree increments (i.e., PI/6, PI/3, PI, 2 * PI/3, 5 * PI/6,
             and 2 * PI)
 
+        Notes
+        -----
+        Parameters marked with the ``rotatable``
+        :class:`~armi.reactor.parameters.parameterDefinitions.Category` will be rotated.
+        These parameters must adhere to one of the following rules to be rotated:
+
+        * triplets of float signifying rotation about the x, y, and z dimension like `Block.p.orientation`, or
+        * vectors of scalars with a number of dimensions equal to the number of edges in the bounding
+          surface of that ``Block`` e.g., ``Block.p.pointsCornerDpa`` should have six elements to be rotatable
+          on a :class:`armi.reactor.blocks.HexBlock`
+        * vectors or arrays with the outer dimension corresponding to a number of pins in a lattice of that
+          block. For example, ``Block.p.percentBuByPin`` is a vector of linear power for each pin in the block.
+          The center pin does not rotate so the first row of ``percentBuByPin`` will not be updated.
+          The first ring of pins has data in entries ``percentBuByPin[1:7]`` and will be shifted to correspond
+          to the new location. Similar for the second ring of pins in ``percentByPyBin[7:19]`` and so on.
+
         """
         rotNum = round((rad % (2 * math.pi)) / math.radians(60))
         self._rotatePins(rotNum)
@@ -2038,9 +2057,15 @@ 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._paramsWhere(
+            lambda pd: pd.hasCategory(Category.rotatable)
+            and (
+                pd.atLocation(ParamLocation.EDGES)
+                or pd.atLocation(ParamLocation.CORNERS)
+            )
+        )
+        for param in params:
+            name = param.name
             original = self.p[name]
             if isinstance(original, (list, np.ndarray)):
                 if len(original) == 6:

armi/reactor/parameters/parameterDefinitions.py

@@ -55,38 +55,39 @@
 
 
 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 come from a thermal hydraulics physics plugin (e.g., flow rates, temperatures, etc.)"""
+    rotatable = "rotatable"
+    """Parameters that should be rotated.
+
+    For parameters defined for and used on hexagonal reactors, see
+    :meth:`armi.reactors.blocks.HexBlock.rotate` for instructions on how rotatable
+    parmeters should be structured."""
 
 
 class ParamLocation(enum.Flag):
@@ -417,10 +418,14 @@ 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
 
+    def hasCategory(self, category: str) -> bool:
+        """True if a parameter has a specific category."""
+        return category in self.categories
+
 
 class ParameterDefinitionCollection:
     """
@@ -438,7 +443,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 +510,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 +576,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
@@ -1451,37 +1451,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 = {}
@@ -1770,6 +1739,81 @@ def test_getReactionRates(self):
         )
 
 
+class BlockRotateTests(unittest.TestCase):
+    """Tests for the ability for a block to be rotated."""
+
+    ROTATABLE_BOUNDARY_PARAMS = ["pointsEdgeDpa", "pointsCornerDpa"]
+
+    STATIC_BOUNDARY_PARAMS = [
+        "cornerFastFlux",
+        "pointsCornerFastFluxFr",
+        "pointsCornerDpaRate",
+        "pointsEdgeFastFluxFr",
+        "pointsEdgeDpaRate",
+    ]
+    BOUNDARY_DATA = np.arange(6, dtype=float) * 10
+
+    def setUp(self):
+        self.block = loadTestBlock()
+        for name in self.STATIC_BOUNDARY_PARAMS + self.ROTATABLE_BOUNDARY_PARAMS:
+            self.block.p[name] = self.BOUNDARY_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.ROTATABLE_BOUNDARY_PARAMS:
+            data = self.block.p[name]
+            msg = f"{name=} :: {rotNum=} :: {data=}"
+            np.testing.assert_array_equal(data, expected, err_msg=msg)
+        for name in self.STATIC_BOUNDARY_PARAMS:
+            data = self.block.p[name]
+            msg = f"{name=} :: {data=}"
+            np.testing.assert_array_equal(data, self.BOUNDARY_DATA, err_msg=msg)
+
+
 class BlockEnergyDepositionConstants(unittest.TestCase):
     """Tests the energy deposition methods.
 

armi/reactor/tests/test_parameters.py

@@ -456,10 +456,18 @@ class MockPC(parameters.ParameterCollection):
         self.assertEqual(p2.categories, set(["awesome", "stuff", "bacon"]))
         self.assertEqual(p3.categories, set(["bacon"]))
 
+        for p in [p1, p2, p3]:
+            self._testCategoryConsistency(p)
+
         self.assertEqual(set(pc.paramDefs.inCategory("awesome")), set([p1, p2]))
         self.assertEqual(set(pc.paramDefs.inCategory("stuff")), set([p1, p2]))
         self.assertEqual(set(pc.paramDefs.inCategory("bacon")), set([p2, p3]))
 
+    def _testCategoryConsistency(self, p: parameters.Parameter):
+        for category in p.categories:
+            self.assertTrue(p.hasCategory(category))
+        self.assertFalse(p.hasCategory("this_shouldnot_exist"))
+
     def test_parameterCollectionsHave__slots__(self):
         """Tests we prevent accidental creation of attributes."""
         self.assertEqual(

doc/release/0.4.rst

@@ -15,6 +15,8 @@ New Features
    :func:`armi.utils.hexagon.getIndexOfRotatedCell`
    (`PR#1846 <https://github.com/terrapower/armi/1846`)
 #. Allow merging a component with zero area into another component (`PR#1858 <https://github.com/terrapower/armi/pull/1858>`_)
+#. :meth:`armi.reactor.blocks.HexBlock.rotate` only rotates parameters that are marked with
+   the ``rotatable`` :class:`~armi.reactor.parameters.parameterDefinitions.Category`
 #. TBD
 
 API Changes