Move cold height expansion to bp

armi/bookkeeping/db/__init__.py

@@ -154,11 +154,13 @@ def loadOperator(pathToDb, loadCycle, loadNode, allowMissing=False):
     updateGlobalAssemblyNum(r)
 
     o = thisCase.initializeOperator(r=r)
-    runLog.warning(
-        "The operator provided is not in the same state as the operator was.\n"
-        "When the reactor was at the prescribed cycle and node, it should have\n"
-        "access to the same interface stack, but the interfaces will also not be in the "
-        "same state.\n"
+    runLog.important(
+        "The operator will not be in the same state that it was at that cycle and "
+        "node, only the reactor.\n"
+        "The operator should have access to the same interface stack, but the "
+        "interfaces will not be in the same state (they will be fresh instances "
+        "of each interface as if __init__ was just called rather than the state "
+        "during the run at this time node.)\n"
         "ARMI does not support loading operator states, as they are not stored."
     )
     return o

armi/reactor/blueprints/__init__.py

@@ -89,7 +89,9 @@
 from armi.reactor import assemblies
 from armi.reactor import geometry
 from armi.reactor import systemLayoutInput
+from armi.reactor.flags import Flags
 from armi.scripts import migration
+
 from armi.utils import textProcessors
 
 # NOTE: using non-ARMI-standard imports because these are all a part of this package,
@@ -102,6 +104,7 @@
 from armi.reactor.blueprints.componentBlueprint import ComponentGroups
 from armi.reactor.blueprints import isotopicOptions
 from armi.reactor.blueprints.gridBlueprint import Grids, Triplet
+from armi.reactor.converters.axialExpansionChanger import AxialExpansionChanger
 
 context.BLUEPRINTS_IMPORTED = True
 context.BLUEPRINTS_IMPORT_CONTEXT = "".join(traceback.format_stack())
@@ -321,18 +324,80 @@ def _prepConstruction(self, cs):
                 self.assemblies[aDesign.name] = a
             if currentCount != 0:
                 assemblies.setAssemNumCounter(currentCount)
-
-            self._checkAssemblyAreaConsistency(cs)
-
             runLog.header("=========== Verifying Assembly Configurations ===========")
+            self._checkAssemblyAreaConsistency(cs)
 
-            # pylint: disable=no-member
-            getPluginManagerOrFail().hook.afterConstructionOfAssemblies(
-                assemblies=self.assemblies.values(), cs=cs
+            # if assemblies are defined in blueprints, handle meshing
+            # assume finest mesh is reference
+            assemsByNumBlocks = sorted(
+                self.assemblies.values(),
+                key=lambda a: len(a),
+                reverse=True,
             )
+            referenceAssembly = assemsByNumBlocks[0] if assemsByNumBlocks else None
+
+            if not cs["detailedAxialExpansion"]:
+                # make the snap lists so assems know how to expand
+                nonUniformAssems = [
+                    Flags.fromStringIgnoreErrors(t) for t in cs["nonUniformAssemFlags"]
+                ]
+                # prepare core for mesh snapping during axial expansion
+                for a in self.assemblies.values():
+                    if any(a.hasFlags(f) for f in nonUniformAssems):
+                        continue
+                    a.makeAxialSnapList(referenceAssembly)
+            if not cs["inputHeightsConsideredHot"]:
+                # expand axial heights from cold to hot
+                self._coldDimsToHot(referenceAssembly, cs["detailedAxialExpansion"])
+
+        # pylint: disable=no-member
+        getPluginManagerOrFail().hook.afterConstructionOfAssemblies(
+            assemblies=self.assemblies.values(), cs=cs
+        )
 
         self._prepped = True
 
+    def _coldDimsToHot(
+        self,
+        referenceAssembly,
+        isDetailedAxialExpansion,
+    ):
+        """
+        Expand BOL assemblies, resolve disjoint axial mesh (if needed), and update block BOL heights
+
+        Parameters
+        ----------
+        assems: list
+            list of :py:class:`Assembly <armi.reactor.assemblies.Assembly>` objects to be thermally expanded
+        """
+        runLog.header(
+            "=========== Axially expanding all assemblies (except control) from Tinput to Thot ==========="
+        )
+        assems = list(self.assemblies.values())
+
+        axialExpChanger = AxialExpansionChanger(isDetailedAxialExpansion)
+        for a in assems:
+            if not a.hasFlags(Flags.CONTROL):
+                axialExpChanger.setAssembly(a)
+                # this doesn't get applied to control assems, so CR will be interpreted
+                # as hot. This should be conservative because the control rods will
+                # be modeled as slightly shorter with the correct hot density. Density
+                # is more important than height, so we are forcing density to be correct
+                # since we can't do axial expansion (yet)
+                axialExpChanger.applyColdHeightMassIncrease()
+                axialExpChanger.expansionData.computeThermalExpansionFactors()
+                axialExpChanger.axiallyExpandAssembly(thermal=True)
+        if not isDetailedAxialExpansion:
+            for a in assems:
+                if not a.hasFlags(Flags.CONTROL):
+                    a.setBlockMesh(referenceAssembly.getAxialMesh())
+        # update block BOL heights to reflect hot heights
+        for a in assems:
+            if not a.hasFlags(Flags.CONTROL):
+                for b in a:
+                    b.p.heightBOL = b.getHeight()
+                    b.completeInitialLoading()
+
     def _assignTypeNums(self):
         if self.blockDesigns is None:
             # this happens when directly defining assemblies.

armi/reactor/reactors.py

@@ -2239,52 +2239,17 @@ def processLoading(self, cs, dbLoad: bool = False):
                 "Please make sure that this is intended and not a input error."
             )
 
-        nonUniformAssems = [
-            Flags.fromStringIgnoreErrors(t) for t in cs["nonUniformAssemFlags"]
-        ]
         if dbLoad:
             # reactor.blueprints.assemblies need to be populated
             # this normally happens during armi/reactor/blueprints/__init__.py::constructAssem
             # but for DB load, this is not called so it must be here.
             # pylint: disable=protected-access
             self.parent.blueprints._prepConstruction(cs)
-            if not cs["detailedAxialExpansion"]:
-                # Apply mesh snapping for self.parent.blueprints.assemblies
-                # This is stored as a param for assemblies in-core, so only blueprints assemblies are
-                # considered here. To guarantee mesh snapping will function, makeAxialSnapList
-                # should be in reference to the assembly with the finest mesh as defined in the blueprints.
-                finestMeshAssembly = sorted(
-                    self.parent.blueprints.assemblies.values(),
-                    key=lambda a: len(a),
-                    reverse=True,
-                )[0]
-                for a in self.parent.blueprints.assemblies.values():
-                    if any(a.hasFlags(f) for f in nonUniformAssems):
-                        continue
-                    a.makeAxialSnapList(refAssem=finestMeshAssembly)
-            if not cs["inputHeightsConsideredHot"]:
-                runLog.header(
-                    "=========== Axially expanding blueprints assemblies (except control) from Tinput to Thot ==========="
-                )
-                self._applyThermalExpansion(
-                    self.parent.blueprints.assemblies.values(),
-                    dbLoad,
-                    finestMeshAssembly,
-                )
-
         else:
-            if not cs["detailedAxialExpansion"]:
-                # prepare core for mesh snapping during axial expansion
-                for a in self.getAssemblies(includeAll=True):
-                    if any(a.hasFlags(f) for f in nonUniformAssems):
-                        continue
-                    a.makeAxialSnapList(self.refAssem)
-            if not cs["inputHeightsConsideredHot"]:
-                runLog.header(
-                    "=========== Axially expanding all assemblies (except control) from Tinput to Thot ==========="
-                )
-                self._applyThermalExpansion(self.getAssemblies(includeAll=True), dbLoad)
-
+            # set reactor level meshing params
+            nonUniformAssems = [
+                Flags.fromStringIgnoreErrors(t) for t in cs["nonUniformAssemFlags"]
+            ]
             # some assemblies, like control assemblies, have a non-conforming mesh
             # and should not be included in self.p.referenceBlockAxialMesh and self.p.axialMesh
             uniformAssems = [
@@ -2360,44 +2325,3 @@ def buildManualZones(self, cs):
 
         if not len(self.zones):
             runLog.debug("No manual zones defined in `zoneDefinitions` setting")
-
-    def _applyThermalExpansion(
-        self, assems: list, dbLoad: bool, referenceAssembly=None
-    ):
-        """expand assemblies, resolve disjoint axial mesh (if needed), and update block BOL heights
-
-        Parameters
-        ----------
-        assems: list
-            list of :py:class:`Assembly <armi.reactor.assemblies.Assembly>` objects to be thermally expanded
-        dbLoad: bool
-            boolean to determine if Core::processLoading is loading a database or constructing a Core
-        referenceAssembly: optional, :py:class:`Assembly <armi.reactor.assemblies.Assembly>`
-            is the thermally expanded assembly whose axial mesh is used to snap the
-            blueprints assemblies axial mesh to
-        """
-        axialExpChngr = AxialExpansionChanger(self._detailedAxialExpansion)
-        for a in assems:
-            if not a.hasFlags(Flags.CONTROL):
-                axialExpChngr.setAssembly(a)
-                # this doesn't get applied to control assems, so CR will be interpreted
-                # as hot. This should be conservative because the control rods will
-                # be modeled as slightly shorter with the correct hot density. Density
-                # is more important than height, so we are forcing density to be correct
-                # since we can't do axial expansion (yet)
-                axialExpChngr.applyColdHeightMassIncrease()
-                axialExpChngr.expansionData.computeThermalExpansionFactors()
-                axialExpChngr.axiallyExpandAssembly(thermal=True)
-        # resolve axially disjoint mesh (if needed)
-        if not dbLoad:
-            axialExpChngr.manageCoreMesh(self.parent)
-        elif not self._detailedAxialExpansion:
-            for a in assems:
-                if not a.hasFlags(Flags.CONTROL):
-                    a.setBlockMesh(referenceAssembly.getAxialMesh())
-        # update block BOL heights to reflect hot heights
-        for a in assems:
-            if not a.hasFlags(Flags.CONTROL):
-                for b in a:
-                    b.p.heightBOL = b.getHeight()
-                    b.completeInitialLoading()

armi/reactor/tests/test_reactors.py

@@ -880,86 +880,74 @@ def test_nonUniformAssems(self):
         self.assertEqual(originalHeights, heights)
 
     def test_applyThermalExpansion_CoreConstruct(self):
-        """test Core::_applyThermalExpansion for core construction
+        """test that assemblies in core are correctly expanded.
 
         Notes:
         ------
         - all assertions skip the first block as it has no $\Delta T$ and does not expand
-        - to maintain code coverage, _applyThermalExpansion is called via processLoading
         """
-        self.o.cs["inputHeightsConsideredHot"] = False
-        assemsToChange = self.r.core.getAssemblies()
+        originalAssems = self.r.core.getAssemblies()
         # stash original axial mesh info
         oldRefBlockAxialMesh = self.r.core.p.referenceBlockAxialMesh
         oldAxialMesh = self.r.core.p.axialMesh
 
         nonEqualParameters = ["heightBOL", "molesHmBOL", "massHmBOL"]
         equalParameters = ["smearDensity", "nHMAtBOL", "enrichmentBOL"]
 
-        oldBlockParameters = {}
-        for param in nonEqualParameters + equalParameters:
-            oldBlockParameters[param] = {}
-            for a in assemsToChange:
-                for b in a[1:]:
-                    oldBlockParameters[param][b] = b.p[param]
+        _o, coldHeightR = loadTestReactor(
+            self.directoryChanger.destination,
+            customSettings={"inputHeightsConsideredHot": False},
+        )
 
-        self.r.core.processLoading(self.o.cs, dbLoad=False)
         for i, val in enumerate(oldRefBlockAxialMesh[1:]):
-            self.assertNotEqual(val, self.r.core.p.referenceBlockAxialMesh[i])
+            self.assertNotEqual(val, coldHeightR.core.p.referenceBlockAxialMesh[i])
         for i, val in enumerate(oldAxialMesh[1:]):
-            self.assertNotEqual(val, self.r.core.p.axialMesh[i])
+            self.assertNotEqual(val, coldHeightR.core.p.axialMesh[i])
 
-        for a in assemsToChange:
+        coldHeightAssems = coldHeightR.core.getAssemblies()
+        for a, coldHeightA in zip(originalAssems, coldHeightAssems):
             if not a.hasFlags(Flags.CONTROL):
-                for b in a[1:]:
+                for b, coldHeightB in zip(a[1:], coldHeightA[1:]):
                     for param in nonEqualParameters:
-                        if oldBlockParameters[param][b] and b.p[param]:
+                        p, coldHeightP = b.p[param], coldHeightB.p[param]
+                        if p and coldHeightP:
                             self.assertNotEqual(
-                                oldBlockParameters[param][b], b.p[param]
+                                p, coldHeightP, f"{param} {p} {coldHeightP}"
                             )
                         else:
-                            self.assertAlmostEqual(
-                                oldBlockParameters[param][b], b.p[param]
-                            )
+                            self.assertAlmostEqual(p, coldHeightP)
                     for param in equalParameters:
-                        self.assertAlmostEqual(oldBlockParameters[param][b], b.p[param])
+                        p, coldHeightP = b.p[param], coldHeightB.p[param]
+                        self.assertAlmostEqual(p, coldHeightP)
 
     def test_updateBlockBOLHeights_DBLoad(self):
-        """test Core::_applyThermalExpansion for db load
+        """Test that blueprints assemblies are expanded in DB load.
 
         Notes:
         ------
         - all assertions skip the first block as it has no $\Delta T$ and does not expand
-        - to maintain code coverage, _applyThermalExpansion is called via processLoading
         """
-        self.o.cs["inputHeightsConsideredHot"] = False
-        assemsToChange = [a for a in self.r.blueprints.assemblies.values()]
-        # stash original blueprint assemblies axial mesh info
+        originalAssems = sorted(a for a in self.r.blueprints.assemblies.values())
         nonEqualParameters = ["heightBOL", "molesHmBOL", "massHmBOL"]
         equalParameters = ["smearDensity", "nHMAtBOL", "enrichmentBOL"]
-        oldBlockParameters = {}
-        for param in nonEqualParameters + equalParameters:
-            oldBlockParameters[param] = {}
-            for a in assemsToChange:
-                for b in a[1:]:
-                    oldBlockParameters[param][b] = b.p[param]
 
-        self.r.core.processLoading(self.o.cs, dbLoad=True)
-
-        for a in assemsToChange:
+        _o, coldHeightR = loadTestReactor(
+            self.directoryChanger.destination,
+            customSettings={"inputHeightsConsideredHot": False},
+        )
+        coldHeightAssems = sorted(a for a in coldHeightR.blueprints.assemblies.values())
+        for a, coldHeightA in zip(originalAssems, coldHeightAssems):
             if not a.hasFlags(Flags.CONTROL):
-                for b in a[1:]:
+                for b, coldHeightB in zip(a[1:], coldHeightA[1:]):
                     for param in nonEqualParameters:
-                        if oldBlockParameters[param][b] and b.p[param]:
-                            self.assertNotEqual(
-                                oldBlockParameters[param][b], b.p[param]
-                            )
+                        p, coldHeightP = b.p[param], coldHeightB.p[param]
+                        if p and coldHeightP:
+                            self.assertNotEqual(p, coldHeightP)
                         else:
-                            self.assertAlmostEqual(
-                                oldBlockParameters[param][b], b.p[param]
-                            )
+                            self.assertAlmostEqual(p, coldHeightP)
                     for param in equalParameters:
-                        self.assertAlmostEqual(oldBlockParameters[param][b], b.p[param])
+                        p, coldHeightP = b.p[param], coldHeightB.p[param]
+                        self.assertAlmostEqual(p, coldHeightP)
 
     def test_buildManualZones(self):
         # define some manual zones in the settings