Adding support for XS groups with numerical labels

armi/physics/neutronics/crossSectionGroupManager.py

@@ -103,17 +103,38 @@ def getXSTypeLabelFromNumber(xsTypeNumber: int) -> str:
 
     2-digit labels are supported when there is only one burnup group.
     """
+    allowableXsTypes = _ALLOWABLE_XS_TYPE_LIST + list(string.digits)
+
     try:
-        if xsTypeNumber > ord("Z"):
-            # two digit. Parse
-            return chr(int(str(xsTypeNumber)[:2])) + chr(int(str(xsTypeNumber)[2:]))
-        elif xsTypeNumber < ord("A"):
-            raise ValueError(
-                f"Cannot convert invalid xsTypeNumber `{xsTypeNumber}` to char. "
-                "The number must be >= 65 (corresponding to 'A')."
-            )
+        xsTypeStr = str(xsTypeNumber)
+
+        if len(xsTypeStr) < 4:
+            # single character
+            label = chr(xsTypeNumber)
+        elif len(xsTypeStr) == 4:
+            # two character, and easy to understand
+            label = chr(int(str(xsTypeNumber)[:2])) + chr(int(str(xsTypeNumber)[2:]))
+        elif len(xsTypeStr) > 6:
+            # This is invalid: three numbers, special characters, or just nonsense.
+            raise ValueError()
         else:
-            return chr(xsTypeNumber)
+            # two characters, but more complicated to figure out
+            firstTwo = chr(int(xsTypeStr[:2]))
+            if firstTwo in allowableXsTypes:
+                label = firstTwo + chr(int(str(xsTypeNumber)[2:]))
+            else:
+                firstThree = chr(int(xsTypeStr[:3]))
+                if firstThree in allowableXsTypes:
+                    label = firstThree + chr(int(str(xsTypeNumber)[3:]))
+                else:
+                    raise ValueError()
+
+        # do some error handling
+        for char in label:
+            if char not in allowableXsTypes:
+                raise ValueError()
+
+        return label
     except ValueError:
         runLog.error(f"Error converting {xsTypeNumber} to label.")
 

armi/physics/neutronics/tests/test_crossSectionManager.py

@@ -1238,18 +1238,76 @@ def test_updateEnvironmentGroups(self):
 
 
 class TestXSNumberConverters(unittest.TestCase):
-    def test_conversion(self):
+    def test_nullCase(self):
+        with self.assertRaises(RuntimeError):
+            crossSectionGroupManager.getXSTypeLabelFromNumber(7)
+
+        with self.assertRaises(RuntimeError):
+            crossSectionGroupManager.getXSTypeLabelFromNumber(244)
+
+        with self.assertRaises(RuntimeError):
+            crossSectionGroupManager.getXSTypeLabelFromNumber(134134)
+
+    def test_oneCapital(self):
         label = crossSectionGroupManager.getXSTypeLabelFromNumber(65)
         self.assertEqual(label, "A")
         num = crossSectionGroupManager.getXSTypeNumberFromLabel("A")
         self.assertEqual(num, 65)
 
-    def test_conversion_2digit(self):
+    def test_twoCapitals(self):
         label = crossSectionGroupManager.getXSTypeLabelFromNumber(6570)
         self.assertEqual(label, "AF")
         num = crossSectionGroupManager.getXSTypeNumberFromLabel("ZZ")
         self.assertEqual(num, 9090)
 
+    def test_oneDigit(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(55)
+        self.assertEqual(label, "7")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("7")
+        self.assertEqual(num, 55)
+
+    def test_twoDigits(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(5056)
+        self.assertEqual(label, "28")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("28")
+        self.assertEqual(num, 5056)
+
+    def test_oneLowercase(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(113)
+        self.assertEqual(label, "q")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("q")
+        self.assertEqual(num, 113)
+
+    def test_twoLowercases(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(104105)
+        self.assertEqual(label, "hi")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("hi")
+        self.assertEqual(num, 104105)
+
+    def test_lowerUpper(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(12088)
+        self.assertEqual(label, "xX")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("xX")
+        self.assertEqual(num, 12088)
+
+    def test_upperLower(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(78111)
+        self.assertEqual(label, "No")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("No")
+        self.assertEqual(num, 78111)
+
+    def test_upperDigit(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(8252)
+        self.assertEqual(label, "R4")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("R4")
+        self.assertEqual(num, 8252)
+
+    def test_digitLower(self):
+        label = crossSectionGroupManager.getXSTypeLabelFromNumber(55122)
+        self.assertEqual(label, "7z")
+        num = crossSectionGroupManager.getXSTypeNumberFromLabel("7z")
+        self.assertEqual(num, 55122)
+
 
 def makeBlocks(howMany=20):
     root = os.path.join(TESTING_ROOT, "reactors", "sodiumHexReactor")

armi/reactor/tests/test_assemblies.py

@@ -870,7 +870,8 @@ def test_reattach(self):
             self.blockParamsTemp = {}
             for key, val in self.blockParams.items():
                 # Iterate with i in self.assemNum, so higher assemNums get the high values.
-                b.p[key] = self.blockParamsTemp[key] = val * (i + 1)
+                v = val if key == "xsTypeNum" else val * (i + 1)
+                b.p[key] = self.blockParamsTemp[key] = v
 
             b.setHeight(self.height)
             b.setType("fuel")

doc/user/inputs.rst

@@ -1022,8 +1022,8 @@ xs types
   Representing xsType by a single capital letter (A-Z), or 2-letter xsType designations if and only if the ``buGroups``
   setting has length 1 (i.e. no burnup groups are defined). This is useful for high-fidelity XS modeling.
 
-  ARMI is able to use lower-case letters (a-z), but this should only be done when working on a case-sensitive file
-  system. On a case-insensitive file system (Windows, and some MacOS systems) this could cause unpredictable errors.
+  ARMI support XS type labels including upper-case (A-Z), lower-case (a-z), and numbers (0-9). But be careful using
+  lower-case letters on case-insensitive file system (Windows, and some MacOS systems) this could cause unpredictable errors.
 
 blocks
    List of blocks in the assembly. The first block listed is defined at the bottom of the core. This is typically a grid plate or some other structure.