def test_TRZyamlIO(self):
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(os.path.join(TEST_ROOT, "trz_geom.xml"))
fName = "testTRZYamlIO.yaml"
with open(fName, "w") as f:
geom._writeYaml(f) # pylint: disable=protected-access
with open(fName) as f:
geom2 = geometry.SystemLayoutInput()
geom2._readYaml(f) # pylint: disable=protected-access
self.assertEqual(geom2.assemTypeByIndices[2.0, 3.0, 0.0, 180.0, 1, 1], "MC")
os.remove(fName)
def test_yamlIO(self):
"""Ensure we can read and write to YAML formatted streams."""
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(GEOM_INPUT))
fName = "testYamlIO.yaml"
with open(fName, "w") as f:
geom._writeYaml(f) # pylint: disable=protected-access
with open(fName) as f:
geom2 = geometry.SystemLayoutInput()
geom2._readYaml(f) # pylint: disable=protected-access
self.assertEqual(geom2.assemTypeByIndices[2, 2], "A2")
os.remove(fName)
def _collectSymmetry(oldDB):
"""Read symmetry and geomType off old-style geometry input str in DB."""
geomPath = "/inputs/geomFile"
if geomPath in oldDB:
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(oldDB["inputs/geomFile"][()]))
return {"symmetry": geom.symmetry, "geomType": geom.geomType}
def migrate(bp: Blueprints, cs):
"""
Apply migrations to the input structure.
This is a good place to perform migrations that address changes to the system design
description (settings, blueprints, geom file). We have access to all three here, so
we can even move stuff between files. Namely, this:
- creates a grid blueprint to represent the core layout from the old ``geomFile``
setting, and applies that grid to a ``core`` system.
- moves the radial and azimuthal submesh values from the ``geomFile`` to the
assembly designs, but only if they are uniform (this is limiting, but could be
made more sophisticated in the future, if there is need)
This allows settings-driven core map to still be used for backwards compatibility.
At some point once the input stabilizes, we may wish to move this out to the
dedicated migration portion of the code, and not perform the migration so
implicitly.
"""
from armi.reactor import blueprints
from armi.reactor.blueprints import gridBlueprint
if bp.systemDesigns is None:
bp.systemDesigns = Systems()
if bp.gridDesigns is None:
bp.gridDesigns = gridBlueprint.Grids()
if "core" in [rd.name for rd in bp.gridDesigns]:
raise ValueError("Cannot auto-create a 2nd `core` grid. Adjust input.")
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(os.path.join(cs.inputDirectory, cs["geomFile"]))
gridDesigns = geom.toGridBlueprints("core")
for design in gridDesigns:
bp.gridDesigns[design.name] = design
if "core" in [rd.name for rd in bp.systemDesigns]:
raise ValueError(
"Core map is defined in both the ``geometry`` setting and in "
"the blueprints file. Only one definition may exist. "
"Update inputs."
)
bp.systemDesigns["core"] = SystemBlueprint("core", "core", Triplet())
if geom.geomType in (geometry.RZT, geometry.RZ):
aziMeshes = {indices[4] for indices, _ in geom.assemTypeByIndices.items()}
radMeshes = {indices[5] for indices, _ in geom.assemTypeByIndices.items()}
if len(aziMeshes) > 1 or len(radMeshes) > 1:
raise ValueError(
"The system layout described in {} has non-uniform "
"azimuthal and/or radial submeshing. This migration is currently "
"only smart enough to handle a single radial and single azimuthal "
"submesh for all assemblies.".format(cs["geomFile"])
)
radMesh = next(iter(radMeshes))
aziMesh = next(iter(aziMeshes))
for _, aDesign in bp.assemDesigns.items():
aDesign.radialMeshPoints = radMesh
aDesign.azimuthalMeshPoints = aziMesh
def loadGeometry(self):
from armi.reactor import geometry
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(
io.StringIO(self._hdf_file["inputs/geomFile"].value))
return geom
def _setGeomType(self):
if self.cs["geomFile"]:
with directoryChangers.DirectoryChanger(self.cs.inputDirectory):
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(self.cs["geomFile"])
self.geomType, self.coreSymmetry = geom.geomType, geom.symmetry
def setUpClass(cls):
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(GEOM_INPUT)
bp = blueprints.Blueprints.load(BLUEPRINT_INPUT_LINKS)
cs = settings.Settings()
bp._prepConstruction(cs)
cls.baseCase = cases.Case(cs=cs, bp=bp, geom=geom)
def testReadHexGeomXML(self):
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(os.path.join(TEST_ROOT, "geom.xml"))
self.assertEqual(geom.geomType, "hex")
self.assertEqual(geom.assemTypeByIndices[(1, 1)], "IC")
out = os.path.join(TEST_ROOT, "geom-output.xml")
geom.writeGeom(out)
os.remove(out)
def test_readAsciimap(self):
geom = geometry.SystemLayoutInput()
geom._readYaml(io.StringIO(GEOM_INPUT_YAML))
self.assertEqual(geom.assemTypeByIndices[(1, 1)], "IC")
self.assertEqual(geom.assemTypeByIndices[(4, 1)], "US")
# check top edge since it's complicated.
self.assertEqual(geom.assemTypeByIndices[(10, 10)], "SH")
self.assertEqual(geom.assemTypeByIndices[(11, 13)], "SH")
def loadGeometry(self):
from armi.reactor import geometry
geom = geometry.SystemLayoutInput()
geomData = self._hdf_file["inputs/geomFile"][()]
if isinstance(geomData, bytes):
# different versions of the code may have outputted these differently,
# possibly when using using python2, or possibly from different versions of
# h5py handling strings differently.
geomData = geomData.decode()
geom.readGeomFromStream(io.StringIO(geomData))
return geom
def getEmptyHexReactor(cs=None):
"""Make an empty hex reactor used in some tests."""
cs = cs or settings.getMasterCs()
bp = blueprints.Blueprints()
geom = geometry.SystemLayoutInput()
geom.symmetry = geometry.THIRD_CORE + geometry.PERIODIC
geom.geomType = geometry.HEX
reactor = reactors.Reactor(cs, bp)
reactor.add(reactors.Core("Core", cs, geom))
reactor.core.spatialGrid = grids.hexGridFromPitch(1.0)
reactor.core.spatialGrid.armiObject = reactor.core
return reactor
def test_growToFullCore(self):
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(GEOM_INPUT))
self.assertNotIn((2, 3), geom.assemTypeByIndices)
self.assertEqual(8, len(geom.assemTypeByIndices))
geom.growToFullCore()
self.assertEqual(geometry.FULL_CORE, geom.symmetry)
self.assertIn((2, 3), geom.assemTypeByIndices)
self.assertIn(
geom.assemTypeByIndices[2, 3], # perodic repeat
geom.assemTypeByIndices[2, 1],
) # from input
self.assertEqual(1 + 6 + 12, len(geom.assemTypeByIndices))
def setUp(self):
self.suite = cases.CaseSuite(settings.Settings())
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(GEOM_INPUT))
bp = blueprints.Blueprints.load(BLUEPRINT_INPUT)
self.c1 = cases.Case(cs=settings.Settings(), geom=geom, bp=bp)
self.c1.cs.path = "c1.yaml"
self.suite.add(self.c1)
self.c2 = cases.Case(cs=settings.Settings(), geom=geom, bp=bp)
self.c2.cs.path = "c2.yaml"
self.suite.add(self.c2)
def setUp(self):
bp = blueprints.Blueprints()
geom = geometry.SystemLayoutInput()
geom.symmetry = "third core periodic"
r = reactors.Reactor(settings.getMasterCs(), bp)
r.add(reactors.Core("Core", settings.getMasterCs(), geom))
r.core.spatialGrid = grids.hexGridFromPitch(1.0)
aList = []
for ring in range(10):
a = assemblies.HexAssembly("fuel")
a.spatialLocator = r.core.spatialGrid[ring, 1, 0]
a.parent = r.core
aList.append(a)
self.aList = aList
def test_independentVariables(self):
"""Ensure that independentVariables added to a case move with it."""
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(GEOM_INPUT))
bp = blueprints.Blueprints.load(BLUEPRINT_INPUT)
cs = settings.Settings(ARMI_RUN_PATH)
cs["verbosity"] = "important"
baseCase = cases.Case(cs, bp=bp, geom=geom)
with directoryChangers.TemporaryDirectoryChanger(
) as cwd: # ensure we are not in IN_USE_TEST_ROOT
vals = {"cladThickness": 1, "control strat": "good", "enrich": 0.9}
case = baseCase.clone()
case._independentVariables = vals # pylint: disable=protected-access
case.writeInputs()
newCs = settings.Settings(fName=case.title + ".yaml")
newCase = cases.Case(newCs)
for name, val in vals.items():
self.assertEqual(newCase.independentVariables[name], val)
def _readGridContentsFile(self):
"""
Read grid contents from a file.
Notes
-----
This reads both the old XML format as well as the new
YAML format. The concept of a grid blueprint is slowly
trying to take over from the geometry file/geometry object.
"""
self.gridContents = {}
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(self.latticeFile)
for indices, spec in geom.assemTypeByIndices.items():
self.gridContents[indices] = spec
self.geom = str(geom.geomType)
self.symmetry = str(geom.symmetry)
# eqPathInput allows fuel management to be input alongside the core grid.
# This would be better as an independent grid but is here for now to help
# migrate inputs from previous versions.
self.eqPathInput = geom.eqPathInput
def test_asciimap(self):
"""Ensure this can write ascii maps"""
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(GEOM_INPUT))
geom._writeAsciiMap()
def test_geomFile(self):
geom = geometry.SystemLayoutInput()
geom.readGeomFromStream(io.StringIO(RTH_GEOM))
gridDesign = geom.toGridBlueprints("test_grid")[0]
def _makeRZGridFromLatticeFile(self):
"""Read an old-style XML file to build a RZT spatial grid."""
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(self.latticeFile)
spatialGrid = grids.thetaRZGridFromGeom(geom)
return spatialGrid
def testReadTRZGeomXML(self):
geom = geometry.SystemLayoutInput()
geom.readGeomFromFile(os.path.join(TEST_ROOT, "trz_geom.xml"))
self.assertEqual(geom.geomType, "thetarz")
self.assertEqual(geom.assemTypeByIndices[(0.0, 2.0, 0.0, 360.0, 1, 1)],
"IC")
