def _perturbTemps(self, block, cName, tCold, tHot):
"Give the component different ref and hot temperatures than in test_Blocks."
c = block.getComponent(Flags.fromString(cName))
c.refTemp, c.refHot = tCold, tHot
c.applyHotHeightDensityReduction()
c.setTemperature(tHot)
return block
def _perturbTemps(self, block, cName, tCold, tHot):
"Give the component different ref and hot temperatures than in test_Blocks."
c = block.getComponent(Flags.fromString(cName))
c.refTemp, c.refHot = tCold, tHot
c.applyMaterialMassFracsToNumberDensities()
c.setTemperature(tHot)
return block
def __init__(self, allNuclidesInProblem, validBlockTypes=None):
list.__init__(self)
self.allNuclidesInProblem = allNuclidesInProblem
self.weightingParam = None
# allowed to be independent of fuel component temperatures b/c Doppler
self.avgNucTemperatures = {}
self._validRepresentativeBlockTypes = None
if validBlockTypes:
self._validRepresentativeBlockTypes = []
for t in validBlockTypes:
self._validRepresentativeBlockTypes.append(Flags.fromString(t))
def _setComponentFlags(component, flags, blueprint):
"""Update component flags based on user input in blueprint"""
# the component __init__ calls setType(), which gives us our initial guess at
# what the flags should be.
if flags is not None:
# override the flags from __init__ with the ones from the blueprint
component.p.flags = Flags.fromString(flags)
else:
# potentially add the DEPLETABLE flag. Don't do this if we set flags
# explicitly. WARNING: If you add flags explicitly, it will
# turn off depletion so be sure to add depletable to your list of flags
# if you expect depletion
if any(nuc in blueprint.activeNuclides
for nuc in component.getNuclides()):
component.p.flags |= Flags.DEPLETABLE
def construct(self, blueprint, matMods):
"""Construct a component"""
runLog.debug("Constructing component {}".format(self.name))
kwargs = self._conformKwargs(blueprint, matMods)
component = components.factory(self.shape.strip().lower(), [], kwargs)
# the component __init__ calls setType(), which gives us our initial guess at
# what the flags should be.
if self.flags is not None:
# override the flags from __init__ with the ones from the blueprint
component.p.flags = Flags.fromString(self.flags)
else:
# potentially add the DEPLETABLE flag. Don't do this if we set flags
# explicitly
_insertDepletableNuclideKeys(component, blueprint)
return component
def _constructAssembly(self, cs, blueprint):
"""Construct the current assembly."""
blocks = []
for axialIndex, bDesign in enumerate(self.blocks):
b = self._createBlock(cs, blueprint, bDesign, axialIndex)
blocks.append(b)
assemblyClass = self.getAssemClass(blocks)
a = assemblyClass(self.name)
flags = None
if self.flags is not None:
flags = Flags.fromString(self.flags)
a.p.flags = flags
# set a basic grid with the right number of blocks with bounds to be adjusted.
a.spatialGrid = grids.axialUnitGrid(len(blocks))
a.spatialGrid.armiObject = a
# TODO: Remove mesh points from blueprints entirely. Submeshing should be
# handled by specific physics interfaces
radMeshPoints = self.radialMeshPoints or 1
a.p.RadMesh = radMeshPoints
aziMeshPoints = self.azimuthalMeshPoints or 1
a.p.AziMesh = aziMeshPoints
# loop a second time because we needed all the blocks before choosing the
# assembly class.
for axialIndex, block in enumerate(blocks):
b.p.assemNum = a.p.assemNum
b.name = b.makeName(a.p.assemNum, axialIndex)
a.add(block)
# Assign values for the parameters if they are defined on the blueprints
for paramDef in a.p.paramDefs.inCategory(
parameters.Category.assignInBlueprints
):
val = getattr(self, paramDef.name)
if val is not None:
a.p[paramDef.name] = val
return a
def schema(val) -> List[Flags]:
"""
Return a list of :py:class:`Flags <armi.reactor.flags.Flags`.
Raises
------
TypeError
When ``val`` is not a list.
ValueError
When ``val`` is not an instance of str or Flags.
"""
if not isinstance(val, list):
raise TypeError(f"Expected `{val}` to be a list.")
flagVals = []
for v in val:
if isinstance(v, str):
flagVals.append(Flags.fromString(v))
elif isinstance(v, Flags):
flagVals.append(v)
else:
raise ValueError(f"Invalid flag input `{v}` in `{self}`")
return flagVals
def construct(self, blueprint, matMods):
"""Construct a component"""
runLog.debug("Constructing component {}".format(self.name))
kwargs = self._conformKwargs(blueprint, matMods)
component = components.factory(self.shape.strip().lower(), [], kwargs)
# the component __init__ calls setType(), which gives us our initial guess at
# what the flags should be.
if self.flags is not None:
# override the flags from __init__ with the ones from the blueprint
component.p.flags = Flags.fromString(self.flags)
else:
# potentially add the DEPLETABLE flag. Don't do this if we set flags
# explicitly. WARNING: If you add flags explicitly, it will
# turn off depletion so be sure to add depletable to your list of flags
# if you expect depletion
if any(nuc in blueprint.activeNuclides for nuc in component.getNuclides()):
component.p.flags |= Flags.DEPLETABLE
if component.hasFlags(Flags.DEPLETABLE):
# depletable components, whether auto-derived or explicitly flagged need expanded nucs
_insertDepletableNuclideKeys(component, blueprint)
return component
def construct(self, cs, blueprint, axialIndex, axialMeshPoints, height,
xsType, materialInput):
"""
Construct an ARMI ``Block`` to be placed in an ``Assembly``.
Parameters
----------
cs : CaseSettings
CaseSettings object for the appropriate simulation.
blueprint : Blueprints
Blueprints object containing various detailed information, such as nuclides to model
axialIndex : int
The Axial index this block exists within the parent assembly
axialMeshPoints : int
number of mesh points for use in the neutronics kernel
height : float
initial height of the block
xsType : str
String representing the xsType of this block.
materialInput : dict
dict containing material modification names and values
"""
runLog.debug("Constructing block {}".format(self.name))
components = collections.OrderedDict()
# build grid before components so you can load
# the components into the grid.
gridDesign = self._getGridDesign(blueprint)
if gridDesign:
spatialGrid = gridDesign.construct()
else:
spatialGrid = None
for componentDesign in self:
c = componentDesign.construct(blueprint, materialInput)
components[c.name] = c
if spatialGrid:
componentLocators = gridDesign.getMultiLocator(
spatialGrid, componentDesign.latticeIDs)
if componentLocators:
# this component is defined in the block grid
# We can infer the multiplicity from the grid.
# Otherwise it's a component that is in a block
# with grids but that's not in the grid itself.
c.spatialLocator = componentLocators
mult = c.getDimension("mult")
if mult and mult != 1.0 and mult != len(c.spatialLocator):
raise ValueError(
f"Conflicting ``mult`` input ({mult}) and number of "
f"lattice positions ({len(c.spatialLocator)}) for {c}. "
"Recommend leaving off ``mult`` input when using grids."
)
elif not mult or mult == 1.0:
# learn mult from grid definition
c.setDimension("mult", len(c.spatialLocator))
for c in components.values():
c._resolveLinkedDims(components)
boundingComp = sorted(components.values())[-1]
# give a temporary name (will be updated by b.makeName as real blocks populate systems)
b = self._getBlockClass(boundingComp)(
name=f"block-bol-{axialIndex:03d}")
for paramDef in b.p.paramDefs.inCategory(
parameters.Category.assignInBlueprints):
val = getattr(self, paramDef.name)
if val is not None:
b.p[paramDef.name] = val
flags = None
if self.flags is not None:
flags = Flags.fromString(self.flags)
b.setType(self.name, flags)
for c in components.values():
b.add(c)
b.p.nPins = b.getNumPins()
b.p.axMesh = _setBlueprintNumberOfAxialMeshes(
axialMeshPoints, cs["axialMeshRefinementFactor"])
b.p.height = height
b.p.heightBOL = height # for fuel performance
b.p.xsType = xsType
b.setBuLimitInfo(cs)
b = self._mergeComponents(b)
b.verifyBlockDims()
b.spatialGrid = spatialGrid
return b
def _plotBlocksInAssembly(
axis,
assem,
isLastAssem,
yBlockHeights,
yBlockAxMesh,
xAssemLoc,
xAssemEndLoc,
showBlockAxMesh,
):
# Set dictionary of pre-defined block types and colors for the plot
lightsage = "xkcd:light sage"
blockTypeColorMap = collections.OrderedDict({
"fuel": "tomato",
"shield": "cadetblue",
"reflector": "darkcyan",
"aclp": "lightslategrey",
"plenum": "white",
"duct": "plum",
"control": lightsage,
"handling socket": "lightgrey",
"grid plate": "lightgrey",
"inlet nozzle": "lightgrey",
})
# Initialize block positions
blockWidth = 5.0
yBlockLoc = 0
xBlockLoc = xAssemLoc
xTextLoc = xBlockLoc + blockWidth / 20.0
for b in assem:
blockHeight = b.getHeight()
blockXsId = b.p.xsType
yBlockCenterLoc = yBlockLoc + blockHeight / 2.5
# Get the basic text label for the block
try:
blockType = [
bType for bType in blockTypeColorMap.keys()
if b.hasFlags(Flags.fromString(bType))
][0]
color = blockTypeColorMap[blockType]
except IndexError:
blockType = b.getType()
color = "grey"
# Get the detailed text label for the block
dLabel = ""
if b.hasFlags(Flags.FUEL):
dLabel = " {:0.2f}%".format(b.getFissileMassEnrich() * 100)
elif b.hasFlags(Flags.CONTROL):
blockType = "ctrl"
dLabel = " {:0.2f}%".format(b.getBoronMassEnrich() * 100)
dLabel += " ({})".format(blockXsId)
# Set up block rectangle
blockPatch = matplotlib.patches.Rectangle(
(xBlockLoc, yBlockLoc),
blockWidth,
blockHeight,
facecolor=color,
alpha=0.7,
edgecolor="k",
lw=1.0,
ls="solid",
)
axis.add_patch(blockPatch)
axis.text(
xTextLoc,
yBlockCenterLoc,
blockType.upper() + dLabel,
ha="left",
fontsize=10,
)
yBlockLoc += blockHeight
yBlockHeights.append(yBlockLoc)
# Add location, block heights, and axial mesh points to ordered set
yBlockAxMesh.add((yBlockCenterLoc, blockHeight, b.p.axMesh))
# Add the block heights, block number of axial mesh points on the far right of the plot.
if isLastAssem and showBlockAxMesh:
xEndLoc = 0.5 + xAssemEndLoc
for bCenter, bHeight, axMeshPoints in yBlockAxMesh:
axis.text(
xEndLoc,
bCenter,
"{} cm ({})".format(bHeight, axMeshPoints),
fontsize=10,
ha="left",
)
return xBlockLoc, yBlockHeights, yBlockAxMesh
def construct(self, cs, blueprint, axialIndex, axialMeshPoints, height,
xsType, materialInput):
"""
Construct an ARMI ``Block`` to be placed in an ``Assembly``.
Parameters
----------
cs : CaseSettings
CaseSettings object for the appropriate simulation.
blueprint : Blueprints
Blueprints object containing various detailed information, such as nuclides to model
axialIndex : int
The Axial index this block exists within the parent assembly
axialMeshPoints : int
number of mesh points for use in the neutronics kernel
height : float
initial height of the block
xsType : str
String representing the xsType of this block.
materialInput : dict
Double-layered dict.
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()
# build grid before components so you can load
# the components into the grid.
gridDesign = self._getGridDesign(blueprint)
if gridDesign:
spatialGrid = gridDesign.construct()
else:
spatialGrid = None
self._checkByComponentMaterialInput(materialInput)
for componentDesign in self:
filteredMaterialInput = self._filterMaterialInput(
materialInput, componentDesign)
c = componentDesign.construct(blueprint, filteredMaterialInput)
if cs["inputHeightsConsideredHot"]:
if "group" in c.name:
for component in c:
component.applyHotHeightDensityReduction()
componentBlueprint.insertDepletableNuclideKeys(
component, blueprint)
else:
c.applyHotHeightDensityReduction()
componentBlueprint.insertDepletableNuclideKeys(
c, blueprint)
components[c.name] = c
if spatialGrid:
componentLocators = gridDesign.getMultiLocator(
spatialGrid, componentDesign.latticeIDs)
if componentLocators:
# this component is defined in the block grid
# We can infer the multiplicity from the grid.
# Otherwise it's a component that is in a block
# with grids but that's not in the grid itself.
c.spatialLocator = componentLocators
mult = c.getDimension("mult")
if mult and mult != 1.0 and mult != len(c.spatialLocator):
raise ValueError(
f"Conflicting ``mult`` input ({mult}) and number of "
f"lattice positions ({len(c.spatialLocator)}) for {c}. "
"Recommend leaving off ``mult`` input when using grids."
)
elif not mult or mult == 1.0:
# learn mult from grid definition
c.setDimension("mult", len(c.spatialLocator))
# Resolve linked dims after all components in the block are created
for c in components.values():
c.resolveLinkedDims(components)
boundingComp = sorted(components.values())[-1]
# give a temporary name (will be updated by b.makeName as real blocks populate systems)
b = self._getBlockClass(boundingComp)(
name=f"block-bol-{axialIndex:03d}")
for paramDef in b.p.paramDefs.inCategory(
parameters.Category.assignInBlueprints):
val = getattr(self, paramDef.name)
if val is not None:
b.p[paramDef.name] = val
flags = None
if self.flags is not None:
flags = Flags.fromString(self.flags)
b.setType(self.name, flags)
for c in components.values():
b.add(c)
b.p.nPins = b.getNumPins()
b.p.axMesh = _setBlueprintNumberOfAxialMeshes(
axialMeshPoints, cs["axialMeshRefinementFactor"])
b.p.height = height
b.p.heightBOL = height # for fuel performance
b.p.xsType = xsType
b.setBuLimitInfo(cs)
b = self._mergeComponents(b)
b.verifyBlockDims()
b.spatialGrid = spatialGrid
if b.spatialGrid is None and cs[globalSettings.CONF_BLOCK_AUTO_GRID]:
try:
b.autoCreateSpatialGrids()
except (ValueError, NotImplementedError) as e:
runLog.warning(str(e), single=True)
return b
