Merge branch 'materialExpansion' of https://github.com/terrapower/armi into materialExpansion

Author: mgjarrett

.github/pull_request_template.md

@@ -13,21 +13,14 @@
 ## Checklist
 
 <!--
-    You (the pull requester) should put an `x` in the boxes below you have completed.
+    You (the pull requester) should put an `x` if the condition is met.
 
     (If a checkbox doesn't apply to your PR, check it anyway.)
 -->
 
 - [ ] This PR has only [one purpose or idea](https://terrapower.github.io/armi/developer/tooling.html#one-idea-one-pr).
 - [ ] [Tests](https://terrapower.github.io/armi/developer/tooling.html#test-it) have been added/updated to verify any new/changed code.
-
-<!-- Check the code quality -->
-
 - [ ] The code style follows [good practices](https://terrapower.github.io/armi/developer/standards_and_practices.html).
-- [ ] The commit message(s) follow [good practices](https://terrapower.github.io/armi/developer/tooling.html).
-
-<!-- Check the project-level cruft -->
-
 - [ ] The [release notes](https://terrapower.github.io/armi/developer/tooling.html#add-release-notes) have been updated if necessary.
 - [ ] The [documentation](https://terrapower.github.io/armi/developer/tooling.html#document-it) is still up-to-date in the `doc` folder.
 - [ ] The dependencies are still up-to-date in `pyproject.toml`.

.github/workflows/docs.yaml

@@ -21,7 +21,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v2
         with:
-          python-version: 3.9
+          python-version: 3.13
       - name: Update package index
         run: sudo apt-get update
       - name: Install mpi libs

armi/apps.py

@@ -115,35 +115,17 @@ def pluginManager(self) -> pluginManager.ArmiPluginManager:
         return self._pm
 
     def getSettings(self) -> Dict[str, Setting]:
-        """
-        Return a dictionary containing all Settings defined by the framework and all plugins.
-
-        .. impl:: Applications will not allow duplicate settings.
-            :id: I_ARMI_SETTINGS_UNIQUE
-            :implements: R_ARMI_SETTINGS_UNIQUE
-
-            Each ARMI application includes a collection of Plugins. Among other
-            things, these plugins can register new settings in addition to
-            the default settings that come with ARMI. This feature provides a
-            lot of utility, so application developers can easily configure
-            their ARMI appliction in customizable ways.
-
-            However, it would get confusing if two different plugins registered
-            a setting with the same name string. Or if a plugin registered a
-            setting with the same name as an ARMI default setting. So this
-            method throws an error if such a situation arises.
-        """
+        """Return a dictionary containing all Settings defined by the framework and all plugins."""
         # Start with framework settings
         settingDefs = {
             setting.name: setting for setting in fwSettings.getFrameworkSettings()
         }
 
-        # The optionsCache stores options that may have come from a plugin before the
-        # setting to which they apply. Whenever a new setting is added, we check to see
-        # if there are any options in the cache, popping them out and adding them to the
-        # setting.  If all plugins' settings have been processed and the cache is not
-        # empty, that's an error, because a plugin must have provided options to a
-        # setting that doesn't exist.
+        # The optionsCache stores options that may have come from a plugin before the setting to
+        # which they apply. Whenever a new setting is added, we check to see if there are any
+        # options in the cache, popping them out and adding them to the setting. If all plugins'
+        # settings have been processed and the cache is not empty, that's an error, because a plugin
+        # must have provided options to a setting that doesn't exist.
         optionsCache: Dict[str, List[settings.Option]] = collections.defaultdict(list)
         defaultsCache: Dict[str, settings.Default] = {}
 
@@ -205,11 +187,10 @@ def getParamRenames(self) -> Dict[str, str]:
         """
         Return the parameter renames from all registered plugins.
 
-        This renders a merged dictionary containing all parameter renames from all of
-        the registered plugins. It also performs simple error checking. The result of
-        this operation is cached, since it is somewhat expensive to perform. If the App
-        detects that its plugin manager's set of registered plugins has changed, the
-        cache will be invalidated and recomputed.
+        This renders a merged dictionary containing all parameter renames from all of the registered
+        plugins. It also performs simple error checking. The result of this operation is cached,
+        since it is somewhat expensive to perform. If the App detects that its plugin manager's set
+        of registered plugins has changed, the cache will be invalidated and recomputed.
         """
         cacheInvalid = False
         if self._paramRenames is not None:

armi/bookkeeping/db/database.py

@@ -724,17 +724,16 @@ def load(
         is read from the database.
 
         .. impl:: Users can load a reactor from a DB.
-            :id: I_ARMI_DB_R_LOAD
-            :implements: R_ARMI_DB_R_LOAD
+            :id: I_ARMI_DB_TIME1
+            :implements: R_ARMI_DB_TIME
 
             This method creates a ``Reactor`` object by reading the reactor state out
             of an ARMI database file. This is done by passing in mandatory arguements
             that specify the exact place in time you want to load the reactor from.
             (That is, the cycle and node numbers.) Users can either pass the settings
             and blueprints directly into this method, or it will attempt to read them
             from the database file. The primary work done here is to read the hierarchy
-            of reactor objects from the data file, then reconstruct them in the correct
-            order.
+            of reactor objects from the data file, then reconstruct them in the correct order.
 
         Parameters
         ----------

armi/bookkeeping/db/layout.py

@@ -383,7 +383,7 @@ def writeToDB(self, h5group):
         """Write a chunk of data to the database.
 
         .. impl:: Write data to the DB for a given time step.
-            :id: I_ARMI_DB_TIME
+            :id: I_ARMI_DB_TIME0
             :implements: R_ARMI_DB_TIME
 
             This method writes a snapshot of the current state of the reactor to the
@@ -393,8 +393,7 @@ def writeToDB(self, h5group):
             objects are written to the file. Though, this turns out to still be very
             powerful. For instance, the data for all ``HexBlock`` children of a given
             parent are stored contiguously within the ``HexBlock`` group, and will not
-            be interleaved with data from the ``HexBlock`` children of any of the
-            parent's siblings.
+            be interleaved with data from the ``HexBlock`` children of any of the parent's siblings.
         """
         if "layout/type" in h5group:
             # It looks like we have already written the layout to DB, skip for now

armi/bookkeeping/db/tests/test_database3.py

@@ -113,8 +113,8 @@ def test_load(self):
         """Load a reactor at different time steps, from the database.
 
         .. test:: Load the reactor from the database.
-            :id: T_ARMI_DB_R_LOAD
-            :tests: R_ARMI_DB_R_LOAD
+            :id: T_ARMI_DB_TIME1
+            :tests: R_ARMI_DB_TIME
         """
         self.makeShuffleHistory()
         with self.assertRaises(KeyError):
@@ -301,7 +301,7 @@ def test_writeToDB(self):
         """Test writing to the database.
 
         .. test:: Write a single time step of data to the database.
-            :id: T_ARMI_DB_TIME
+            :id: T_ARMI_DB_TIME0
             :tests: R_ARMI_DB_TIME
         """
         self.r.p.cycle = 0

armi/bookkeeping/report/reportingUtils.py

@@ -476,8 +476,8 @@ def writeAssemblyMassSummary(r):
             blockType = b.getType()
             if blockType not in types:
                 types.append(blockType)
-        # if the BOL fuel assem is in the center of the core, its area is 1/3 of the full area b/c it's a sliced assem.
-        # bug: mass came out way high for a case once. 265 MT vs. 92 MT hm.
+        # If the BOL fuel assem is in the center of the core, its area is 1/3 of the full area b/c
+        # its a sliced assem.
 
         # count assemblies
         core = r.core

armi/cases/tests/test_cases.py

@@ -648,13 +648,7 @@ def test_copyInterfaceInputs_nonFilePath(self):
             self.assertEqual(newSettings[testSetting], fakeShuffle)
 
     def test_failOnDuplicateSetting(self):
-        """
-        That that if a plugin attempts to add a duplicate setting, it raises an error.
-
-        .. test:: Plugins cannot register duplicate settings.
-            :id: T_ARMI_SETTINGS_UNIQUE
-            :tests: R_ARMI_SETTINGS_UNIQUE
-        """
+        """That that if a plugin attempts to add a duplicate setting, it raises an error."""
         # register the new Plugin
         app = getApp()
         app.pluginManager.register(TestPluginWithDuplicateSetting)

armi/materials/material.py

@@ -146,18 +146,7 @@ def __repr__(self):
 
     @property
     def name(self):
-        """
-        Getter for the private name attribute of this Material.
-
-        .. impl:: The name of a material is accessible.
-            :id: I_ARMI_MAT_NAME
-            :implements: R_ARMI_MAT_NAME
-
-            Every instance of an ARMI material must have a simple, human-readable string name. And,
-            if possible, we want this string to match the class name. (This, of course, puts some
-            limits on both the string and the class name.) These names are easily retrievable as a
-            class property.
-        """
+        """Getter for the private name attribute of this Material."""
         return self._name
 
     @name.setter
@@ -757,6 +746,12 @@ def adjustTD(self, val):
 class Fluid(Material):
     """A material that fills its container. Could also be a gas."""
 
+    def __init_subclass__(cls):
+        # Undo the parent-aware density wrapping. Fluids do not expand in the same way solids, so
+        # Fluid.density(T) is correct. This does not hold for solids because they thermally expand.
+        if hasattr(cls.density, "__wrapped__"):
+            cls.density = cls.density.__wrapped__
+
     def getThermalExpansionDensityReduction(self, prevTempInC, newTempInC):
         """Return the factor required to update thermal expansion going from one temperature (in
         Celcius) to a new temperature.

armi/materials/tests/test_fluids.py

@@ -0,0 +1,63 @@
+# Copyright 2025 TerraPower, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Unit tests for fluid-specific behaviors.
+
+The ARMI framework has a lot of thermal expansion machinery that applies to all components
+but doesn't make sense for fluids. The tests here help show fluid materials still
+play nice with the rest of the framework.
+"""
+
+from unittest import TestCase
+
+from armi.materials.material import Fluid, Material
+from armi.reactor.components import Circle
+from armi.tests import mockRunLogs
+
+
+class TestFluids(TestCase):
+    class MyFluid(Fluid):
+        """Stand-in fluid that doesn't provide lots of functionality."""
+
+    class MySolid(Material):
+        """Stand-in solid that doesn't provide lots of functionality."""
+
+    def test_fluidDensityWrapperNoWarning(self):
+        """Test that Component.material.density does not raise a warning for fluids.
+
+        The ARMI Framework contains a mechanism to warn users if they ask for the density of a
+        material attached to a component. But the component is the source of truth for volume and
+        composition. And can be thermally expanded during operation. Much of the framework operates
+        on ``Component.density`` and other ``Component`` methods for mass accounting. However,
+        ``comp.material.density`` does not know about the new composition or volumes and can diverge
+        from ``component.density``.
+
+        Additionally, the framework does not do any thermal expansion on fluids. So the above calls
+        to ``component.material.density`` are warranted for fluids.
+        """
+        self._checkCompDensityLogs(
+            mat=self.MySolid(),
+            nExpectedWarnings=1,
+            msg="Solids should have the density warning logged.",
+        )
+        self._checkCompDensityLogs(
+            mat=self.MyFluid(),
+            nExpectedWarnings=0,
+            msg="Fluids should not have the density warning logged.",
+        )
+
+    def _checkCompDensityLogs(self, mat: Material, nExpectedWarnings: int, msg: str):
+        comp = Circle(name="test", material=mat, Tinput=20, Thot=20, id=0, od=1, mult=1)
+        with mockRunLogs.LogCounter() as logs:
+            comp.material.density(Tc=comp.temperatureInC)
+        self.assertEqual(logs.messageCounts["warning"], nExpectedWarnings, msg=msg)