Allow components to have children in support of particle fuel modeling

armi/reactor/blocks.py

@@ -276,7 +276,7 @@ def getSmearDensity(self, cold=True):
         # Compute component areas
         cladID = numpy.mean([clad.getDimension("id", cold=cold) for clad in clads])
         innerCladdingArea = (
-            math.pi * (cladID ** 2) / 4.0 * self.getNumComponents(Flags.FUEL)
+            math.pi * (cladID**2) / 4.0 * self.getNumComponents(Flags.FUEL)
         )
         fuelComponentArea = 0.0
         unmovableComponentArea = 0.0
@@ -751,6 +751,43 @@ def _updateDetailedNdens(self, frac, adjustList):
             # on the interface stack.
             self.p.pdensDecay *= frac
 
+    def updateComponentGroupMults(self):
+        """
+        Update component group mults.
+
+        This applies only to block child components that themselves have child components.
+
+        They were temporarily set to the desired blend fraction during component
+        construction. This derives the actual multiplicity based on the target
+        blend fraction.
+
+        Note that the blend fractions are applied to the hot thermally-expanded
+        dimensions.
+
+        In order to account properly for the mass of the background material
+        in addition to the materials of the children, we must also shrink
+        the background component's mult.
+
+        See Also
+        --------
+        reactor.blueprints.componentBlueprint.ComponentBlueprint : sets the mults
+        reactor.blurprints.blockBlueprint.BlockBlueprint.construct : calls this
+        """
+        for c in self.getChildren():
+            if len(c) > 1:
+                backgroundVol = c.getVolume()
+                # expect all mults to be temporarily set to blend frac from blueprints
+                blendFrac = c[0].p.mult
+                # remove scaling by mult=blendFrac here
+                childVol = sum(subchild.getVolume() / blendFrac for subchild in c)
+                # mult should be such that childVol/backgroundVol = blendFrac
+                # so: childVol * newMult = blendFrac * backgroundVol
+                newMult = blendFrac * backgroundVol / childVol
+                for subchild in c:
+                    subchild.setDimension("mult", newMult)
+                # shrink background component to fit
+                c.setDimension("mult", c.p.mult * (1 - blendFrac))
+
     def completeInitialLoading(self, bolBlock=None):
         """
         Does some BOL bookkeeping to track things like BOL HM density for burnup tracking.
@@ -1905,14 +1942,10 @@ def getSymmetryFactor(self):
                 # seeing the first one is the easiest way to detect them.
                 # Check it last in the and statement so we don't waste time doing it.
                 upperEdgeLoc = self.core.spatialGrid[-1, 2, 0]
-                if (
-                    symmetryLine
-                    in [
-                        grids.BOUNDARY_0_DEGREES,
-                        grids.BOUNDARY_120_DEGREES,
-                    ]
-                    and bool(self.core.childrenByLocator.get(upperEdgeLoc))
-                ):
+                if symmetryLine in [
+                    grids.BOUNDARY_0_DEGREES,
+                    grids.BOUNDARY_120_DEGREES,
+                ] and bool(self.core.childrenByLocator.get(upperEdgeLoc)):
                     return 2.0
         return 1.0
 
@@ -1950,11 +1983,15 @@ def autoCreateSpatialGrids(self):
 
         ringNumber = hexagon.numRingsToHoldNumCells(self.getNumPins())
         # For the below to work, there must not be multiple wire or multiple clad types.
+        pitch = self.getPinPitch(cold=True)
+        if pitch is None:
+            raise ValueError(
+                f"Could not create spatialGrid for block {self.p.type} "
+                "because the pin pitch was not detected."
+            )
         # note that it's the pointed end of the cell hexes that are up (but the
         # macro shape of the pins forms a hex with a flat top fitting in the assembly)
-        grid = grids.HexGrid.fromPitch(
-            self.getPinPitch(cold=True), numRings=0, pointedEndUp=True
-        )
+        grid = grids.HexGrid.fromPitch(pitch, numRings=0, pointedEndUp=True)
         spatialLocators = grids.MultiIndexLocation(grid=self.spatialGrid)
         numLocations = 0
         for ring in range(ringNumber):

armi/reactor/blueprints/blockBlueprint.py

@@ -101,6 +101,7 @@ def construct(
             Top layer groups the by-block material modifications under the `byBlock` key
             and the by-component material modifications under the component's name.
             The inner dict under each key contains material modification names and values.
+
         """
         runLog.debug("Constructing block {}".format(self.name))
         components = collections.OrderedDict()
@@ -194,6 +195,11 @@ def construct(
                 b.autoCreateSpatialGrids()
             except (ValueError, NotImplementedError) as e:
                 runLog.warning(str(e), single=True)
+
+        # now that components are in blocks we have heights and can actually
+        # compute the mults of the component groups.
+        b.updateComponentGroupMults()
+
         return b
 
     def _checkByComponentMaterialInput(self, materialInput):

armi/reactor/blueprints/componentBlueprint.py

@@ -153,6 +153,8 @@ def shape(self, shape):  # pylint: disable=no-self-use; reason=yamlize requireme
     isotopics = yamlize.Attribute(type=str, default=None)
     latticeIDs = yamlize.Attribute(type=list, default=None)
     origin = yamlize.Attribute(type=list, default=None)
+    blends = yamlize.Attribute(type=list, default=None)
+    blendFracs = yamlize.Attribute(type=list, default=None)
     orientation = yamlize.Attribute(type=str, default=None)
     mergeWith = yamlize.Attribute(type=str, default=None)
     area = yamlize.Attribute(type=float, default=None)
@@ -175,9 +177,49 @@ def construct(self, blueprint, matMods):
                 constructedObject.add(component)
 
         else:
-            constructedObject = components.factory(shape, [], kwargs)
-            _setComponentFlags(constructedObject, self.flags, blueprint)
-            insertDepletableNuclideKeys(constructedObject, blueprint)
+            if self.blends:
+                # build a blended object
+                for groupName, blendFrac in zip(self.blends, self.blendFracs):
+                    # blendFrac is a volume fraction, and so we need to adjust the multiplicities
+                    # so that the background component and the child group match up
+                    # The area of the background component will be fully determined by its dims and mult.
+                    # but internally, its number densities and volumes need to be set to match
+                    # the blendFrac
+                    group = blueprint.componentGroups[groupName]
+                    # strip off the blend/blendFrac args since they aren't valid on any
+                    # specific shape's constructor
+                    del kwargs["blends"]
+                    del kwargs["blendFracs"]
+                    # build the background object
+                    constructedObject = components.factory(shape, [], kwargs)
+                    # build the child objects
+                    # all grouped components have to be input with the same mult for now
+                    inputMult = None
+                    for groupedComponent in group:
+                        componentDesign = blueprint.componentDesigns[
+                            groupedComponent.name
+                        ]
+                        if inputMult is None:
+                            inputMult = componentDesign.mult 
+                        if componentDesign.mult != inputMult:
+                            raise ValueError(
+                                f"Grouped components must all have the same input mult of {inputMult}"
+                            )
+                        component = componentDesign.construct(blueprint, matMods=dict())
+                        # temporarily set grouped component mults to the blend fraction
+                        # these will be updated based on parent component volume
+                        # during block construction
+                        component.setDimension("mult", blendFrac)
+                        _setComponentFlags(component, self.flags, blueprint)
+                        insertDepletableNuclideKeys(component, blueprint)
+                        constructedObject.add(component)
+                    children = {c.name: c for c in constructedObject.getChildren()}
+                    for child in children.values():
+                        child.resolveLinkedDims(children)
+            else:
+                constructedObject = components.factory(shape, [], kwargs)
+                _setComponentFlags(constructedObject, self.flags, blueprint)
+                insertDepletableNuclideKeys(constructedObject, blueprint)
         return constructedObject
 
     def _conformKwargs(self, blueprint, matMods):

armi/reactor/components/component.py

@@ -609,30 +609,42 @@ def getNuclides(self):
 
         This includes anything that has been specified in here, including trace nuclides.
         """
-        return list(self.p.numberDensities.keys())
+        nucs = set(self.p.numberDensities.keys())
+        if self._children:
+            childNuclides = set(composites.Composite.getNuclides(self))
+            nucs |= childNuclides
+        return nucs
 
-    def getNumberDensity(self, nucName):
+    def getNuclideNumberDensities(self, nucNames):
         """
-        Get the number density of nucName, return zero if it does not exist here.
+        Return a list of number densities for the nuc names requested.
 
-        Parameters
-        ----------
-        nucName : str
-            Nuclide name
+        If this Component has children, then homogenize their number densities in.
 
-        Returns
-        -------
-        number density : float
-            number density in atoms/bn-cm.
+        Component ndens is unique in that it combines its own actual composition
+        with that of its potential children
         """
-        return self.p.numberDensities.get(nucName, 0.0)
-
-    def getNuclideNumberDensities(self, nucNames):
-        """Return a list of number densities for the nuc names requested."""
-        return [self.p.numberDensities.get(nucName, 0.0) for nucName in nucNames]
 
-    def _getNdensHelper(self):
-        return dict(self.p.numberDensities)
+        if self._children:
+            childDens = dict(
+                zip(
+                    nucNames,
+                    composites.Composite.getNuclideNumberDensities(self, nucNames),
+                )
+            )
+            # get volume of children by using the composite method which loops over all children
+            childVol = composites.Composite.getVolume(self)
+            # get self volume by calling the shape-specific volume method of the background shape
+            totalVol = self.getVolume()
+            childFrac = childVol / totalVol
+            selfFrac = 1.0 - childFrac
+            return [
+                self.p.numberDensities.get(nucName, 0.0) * selfFrac
+                + childDens.get(nucName, 0.0) * childFrac
+                for nucName in nucNames
+            ]
+        else:
+            return [self.p.numberDensities.get(nucName, 0.0) for nucName in nucNames]
 
     def setName(self, name):
         """Components use name for type and name."""
@@ -1019,8 +1031,20 @@ def mergeNuclidesInto(self, compToMergeWith):
             )
 
     def iterComponents(self, typeSpec=None, exact=False):
-        if self.hasFlags(typeSpec, exact):
-            yield self
+        """
+        Yield the component or its direct child components.
+
+        Notes
+        -----
+        This could probably be made recursive to allow arbitrary depth, but it's more complex
+        """
+        if self._children:
+            for child in self._children:
+                if self.hasFlags(typeSpec, exact):
+                    yield child
+        else:
+            if self.hasFlags(typeSpec, exact):
+                yield self
 
     def backUp(self):
         """

armi/reactor/composites.py

@@ -1237,7 +1237,13 @@ def getNumberDensity(self, nucName):
         return self.getNuclideNumberDensities([nucName])[0]
 
     def getNuclideNumberDensities(self, nucNames):
-        """Return a list of number densities in atoms/barn-cm for the nuc names requested."""
+        """
+        Return a list of number densities in atoms/barn-cm for the nuc names requested.
+
+        See Also
+        --------
+        getNumberDensities: Gets all number densities as a dict rather than a list
+        """
         volumes = numpy.array(
             [
                 c.getVolume() / (c.parent.getSymmetryFactor() if c.parent else 1.0)
@@ -1284,6 +1290,10 @@ def getNumberDensities(self, expandFissionProducts=False):
         -------
         numberDensities : dict
             nucName keys, number density values (atoms/bn-cm)
+
+        See Also
+        --------
+        getNuclideNumberDensities: Gets a list of number densities based on a list of nuclide names
         """
         numberDensities = self._getNdensHelper()
         if expandFissionProducts: