def test_reattach(
self,
): # TODO: this got changed, should make sure it still tests what is intended
# Remake original assembly
self.Assembly = makeTestAssembly(self.assemNum, self.assemNum)
# add some blocks with a component
for i in range(self.assemNum):
b = blocks.HexBlock("TestBlock", self.cs)
# Set the 1st block to have higher params than the rest.
self.blockParamsTemp = {}
for key, val in self.blockParams.items():
b.p[key] = self.blockParamsTemp[key] = val * (
i + 1
) # Iterate with i in self.assemNum, so higher assemNums get the high values.
b.setHeight(self.height)
b.setType("fuel")
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
h = components.Hexagon("intercoolant", "Sodium", **self.hexDims)
b.add(h)
self.Assembly.add(b)
def test_reattach(self):
# Remake original assembly
self.assembly = makeTestAssembly(self.assemNum, self.assemNum)
self.assertEqual(0, len(self.assembly.getBlocks()))
# add some blocks with a component
for i in range(self.assemNum):
b = blocks.HexBlock("TestBlock")
# Set the 1st block to have higher params than the rest.
self.blockParamsTemp = {}
for key, val in self.blockParams.items():
# Iterate with i in self.assemNum, so higher assemNums get the high values.
b.p[key] = self.blockParamsTemp[key] = val * (i + 1)
b.setHeight(self.height)
b.setType("fuel")
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
h = components.Hexagon("intercoolant", "Sodium", **self.hexDims)
b.add(h)
self.assembly.add(b)
self.assertEqual(self.assemNum, len(self.assembly.getBlocks()))
for b in self.assembly.getBlocks():
self.assertEqual("fuel", b.getType())
def test_makeAxialSnapList(self):
# Make a second assembly with 4 times the resolution
assemNum2 = self.assemNum * 4
height2 = self.height / 4.0
assembly2 = makeTestAssembly(assemNum2, assemNum2)
# add some blocks with a component
for _i in range(assemNum2):
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
h = components.Hexagon("fuel", "UZr", **self.hexDims)
b = blocks.HexBlock("fuel")
b.setType("igniter fuel")
b.add(h)
b.setHeight(height2)
assembly2.add(b)
self.assembly.makeAxialSnapList(assembly2)
cur = []
for b in self.assembly:
cur.append(b.p.topIndex)
ref = [3, 7, 11]
self.assertEqual(cur, ref)
def setUp(self):
r"""
Build a dummy reactor without using input files. There are some igniters and feeds
but none of these have any number densities.
"""
self.o, self.r = test_reactors.loadTestReactor(
self.directoryChanger.destination
)
blockList = self.r.core.getBlocks()
for bi, b in enumerate(blockList):
b.p.flux = 5e10
if b.isFuel():
b.p.percentBu = 30.0 * bi / len(blockList)
self.nfeed = len(self.r.core.getAssemblies(Flags.FEED))
self.nigniter = len(self.r.core.getAssemblies(Flags.IGNITER))
self.nSfp = len(self.r.core.sfp)
# generate a reactor with assemblies
# generate components with materials
nPins = 271
fuelDims = {"Tinput": 273.0, "Thot": 273.0, "od": 1.0, "id": 0.0, "mult": nPins}
fuel = components.Circle("fuel", "UZr", **fuelDims)
cladDims = {"Tinput": 273.0, "Thot": 273.0, "od": 1.1, "id": 1.0, "mult": nPins}
clad = components.Circle("clad", "HT9", **cladDims)
interDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 16.8,
"ip": 16.0,
"mult": 1.0,
}
interSodium = components.Hexagon("interCoolant", "Sodium", **interDims)
# generate a block
self.block = blocks.HexBlock("TestHexBlock", self.o.cs)
self.block.setType("fuel")
self.block.setHeight(10.0)
self.block.add(fuel)
self.block.add(clad)
self.block.add(interSodium)
# generate an assembly
self.assembly = assemblies.HexAssembly("TestAssemblyType")
self.assembly.spatialGrid = grids.axialUnitGrid(1)
for _ in range(1):
self.assembly.add(copy.deepcopy(self.block))
# copy the assembly to make a list of assemblies and have a reference assembly
self.aList = []
for _ in range(6):
self.aList.append(copy.deepcopy(self.assembly))
self.refAssembly = copy.deepcopy(self.assembly)
self.directoryChanger.open()
def test_calcTotalParam(self):
# Remake original assembly
self.assembly = makeTestAssembly(self.assemNum, self.assemNum)
# add some blocks with a component
for i in range(self.assemNum):
b = blocks.HexBlock("TestBlock")
# Set the 1st block to have higher params than the rest.
self.blockParamsTemp = {}
for key, val in self.blockParams.items():
b.p[key] = self.blockParamsTemp[key] = (
val * i
) # Iterate with i in self.assemNum, so higher assemNums get the high values.
b.setHeight(self.height)
b.setType("fuel")
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
h = components.Hexagon("intercoolant", "Sodium", **self.hexDims)
b.add(h)
self.assembly.add(b)
for param in self.blockParamsTemp:
tot = 0.0
for b in self.assembly:
try:
tot += b.p[param]
except TypeError:
pass
ref = tot
try:
cur = self.assembly.calcTotalParam(param)
places = 6
self.assertAlmostEqual(cur, ref, places=places)
except TypeError:
pass
def buildTestAssemblies():
"""
Build some assembly objects that will be used in testing.
This builds 2 HexBlocks:
* One with half UZr pins and half UTh pins
* One with all UThZr pins
"""
caseSetting = settings.Settings()
settings.setMasterCs(caseSetting)
temperature = 273.0
fuelID = 0.0
fuelOD = 1.0
cladOD = 1.1
# generate a reactor with assemblies
# generate components with materials
nPins = 100
fuelDims = {
"Tinput": temperature,
"Thot": temperature,
"od": fuelOD,
"id": fuelID,
"mult": nPins,
}
fuelUZr = components.Circle("fuel", "UZr", **fuelDims)
fuelUTh = components.Circle("fuel UTh", "ThU", **fuelDims)
fuelDims2nPins = {
"Tinput": temperature,
"Thot": temperature,
"od": fuelOD,
"id": fuelID,
"mult": 2 * nPins,
}
fuelUThZr = components.Circle("fuel B", "UThZr", **fuelDims2nPins)
cladDims = {
"Tinput": temperature,
"Thot": temperature,
"od": cladOD,
"id": fuelOD,
"mult": 2 * nPins,
}
clad = components.Circle("clad", "HT9", **cladDims)
interDims = {
"Tinput": temperature,
"Thot": temperature,
"op": 16.8,
"ip": 16.0,
"mult": 1.0,
}
interSodium = components.Hexagon("interCoolant", "Sodium", **interDims)
block = blocks.HexBlock("fuel")
block2 = blocks.HexBlock("fuel")
block.setType("fuel")
block.setHeight(10.0)
block.add(fuelUZr)
block.add(fuelUTh)
block.add(clad)
block.add(interSodium)
block.p.axMesh = 1
block.p.molesHmBOL = 1.0
block.p.molesHmNow = 1.0
block2.setType("fuel")
block2.setHeight(10.0)
block2.add(fuelUThZr)
block2.add(clad)
block2.add(interSodium)
block2.p.axMesh = 1
block2.p.molesHmBOL = 2
block2.p.molesHmNow = 1.0
assemblieObjs = []
for numBlocks, blockTemplate in zip([1, 1, 5, 4],
[block, block2, block, block]):
assembly = assemblies.HexAssembly("testAssemblyType")
assembly.spatialGrid = grids.axialUnitGrid(numBlocks)
assembly.spatialGrid.armiObject = assembly
for _i in range(numBlocks):
newBlock = copy.deepcopy(blockTemplate)
assembly.add(newBlock)
assembly.calculateZCoords()
assembly.reestablishBlockOrder()
assemblieObjs.append(assembly)
return assemblieObjs
def setUp(self):
self.name = "A0015"
self.assemNum = 15
self.height = 10
self.cs = settings.getMasterCs()
# Print nothing to the screen that would normally go to the log.
runLog.setVerbosity("error")
self.r = tests.getEmptyHexReactor()
self.r.core.symmetry = geometry.SymmetryType(
geometry.DomainType.THIRD_CORE, geometry.BoundaryType.PERIODIC)
self.assembly = makeTestAssembly(NUM_BLOCKS, self.assemNum, r=self.r)
self.r.core.add(self.assembly)
# Use these if they are needed
self.blockParams = {
"height": self.height,
"avgFuelTemp": 873.0,
"bondRemoved": 0.0,
"bu": 15.1,
"buGroupNum": 0,
"buLimit": 35,
"buRate": 0.0,
"eqRegion": -1,
"id": 212.0,
"pdens": 10.0,
"percentBu": 25.3,
"power": 100000.0,
"residence": 4.0,
"smearDensity": 0.6996721711791459,
"timeToLimit": 2.7e5,
"xsTypeNum": 40,
"zbottom": 97.3521,
"ztop": 111.80279999999999,
}
self.blockSettings = {
"axMesh": 1,
"baseBu": 0.0,
"basePBu": 0.0,
"bondBOL": 0.0028698019026172574,
"buGroup": "A",
"height": 14.4507,
"molesHmAtBOL": 65.8572895758245,
"nHMAtBOL": 0.011241485251783766,
"nPins": 169.0,
"name": "B0011F",
"newDPA": 0.0,
"pitch": 16.79,
"regName": False,
"topIndex": 5,
"tsIndex": 0,
"type": "igniter fuel",
"xsType": "C",
"z": 104.57745,
}
# add some blocks with a component
self.blockList = []
for i in range(NUM_BLOCKS):
b = blocks.HexBlock("TestHexBlock")
b.setHeight(self.height)
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
h = components.Hexagon("fuel", "UZr", **self.hexDims)
# non-flaggy name important for testing
b.setType("igniter fuel unitst")
b.add(h)
b.parent = self.assembly
b.setName(b.makeName(self.assembly.getNum(), i))
self.assembly.add(b)
self.blockList.append(b)
self.assembly.calculateZCoords()
def test_axiallyExpand(self):
"""Build an assembly, grow it, and check it."""
self.assemNum = 5
# Remake original assembly
self.r.core.removeAssembly(self.Assembly)
self.Assembly = makeTestAssembly(self.assemNum,
self.assemNum,
r=self.r)
self.r.core.add(self.Assembly)
# add some blocks with a component
for blockI in range(self.assemNum):
b = blocks.HexBlock("TestBlock", self.cs)
# Set the 1st block to have higher params than the rest.
self.blockParamsTemp = {}
for key, val in self.blockParams.items():
b.p[key] = self.blockParamsTemp[key] = val * (
blockI + 1
) # Iterate with i in self.assemNum, so higher assemNums get the high values.
b.setHeight(self.height)
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
if (blockI == 0) or (blockI == 4):
b.setType("plenum")
h = components.Hexagon("intercoolant", "Sodium",
**self.hexDims)
else:
b.setType("fuel")
h = components.Hexagon("fuel", "UZr", **self.hexDims)
b.add(h)
self.Assembly.add(b)
expandFrac = 1.15
adjustList = ["U238", "ZR", "U235"]
# Get the original block heights and densities to compare to later.
heights = {
} # Dictionary with keys of block number, values of block heights.
densities = (
{}
) # Dictionary with keys of block number, values of dictionaries with keys of nuclide, values of block nuclide density
for i, b in enumerate(self.Assembly):
heights[i] = b.getHeight()
densities[i] = {}
for nuc, dens in b.getNumberDensities().items():
densities[i][nuc] = dens
expandPercent = (expandFrac - 1) * 100
self.Assembly.axiallyExpand(expandPercent, adjustList)
for i, b in enumerate(self.Assembly):
# Check height
if i == 0:
# bottom block should be unchanged (because plenum)
ref = heights[i]
elif i == 4:
# plenum on top should have grown by 15% of the uniform height * 3 (for each fuel block)
ref = heights[i] - (expandFrac - 1) * 3 * heights[i]
else:
# each of the three fuel blocks should be 15% bigger.
ref = heights[i] * expandFrac
self.assertAlmostEqual(b.getHeight(), ref)
# Check densities
for nuc, dens in b.getNumberDensities().items():
if (i == 0) or (i == 4):
# these blocks should be unchanged in mass/density.
ref = densities[i][nuc]
else:
# fuel blocks should have all three nuclides reduced.
ref = densities[i][nuc] / expandFrac
places = 6
self.assertAlmostEqual(dens, ref, places=places)
def test_axiallyExpandBlockHeights(self):
r"""heightList = list of floats. Entry 0 represents the bottom fuel block closest to the grid plate.
Entry n represents the top fuel block closes to the plenum
adjust list = list of nuclides to modify"""
self.assemNum = 5
# Remake original assembly
self.r.core.removeAssembly(self.Assembly)
self.Assembly = makeTestAssembly(self.assemNum,
self.assemNum,
r=self.r)
self.r.core.add(self.Assembly)
# add some blocks with a component
for i in range(self.assemNum):
b = blocks.HexBlock("TestBlock", self.cs)
# Set the 1st block to have higher params than the rest.
self.blockParamsTemp = {}
for key, val in self.blockParams.items():
b.p[key] = self.blockParamsTemp[key] = val * (
i + 1
) # Iterate with i in self.assemNum, so higher assemNums get the high values.
b.setHeight(self.height)
self.hexDims = {
"Tinput": 273.0,
"Thot": 273.0,
"op": 0.76,
"ip": 0.0,
"mult": 1.0,
}
if (i == 0) or (i == 4):
b.setType("plenum")
h = components.Hexagon("intercoolant", "Sodium",
**self.hexDims)
else:
b.setType("fuel")
h = components.Hexagon("fuel", "UZr", **self.hexDims)
b.add(h)
self.Assembly.add(b)
expandFrac = 1.15
heightList = [
self.height * expandFrac for x in range(self.assemNum - 2)
]
adjustList = ["U238", "ZR", "U235"]
# Get the original block heights and densities to compare to later.
heights = {
} # Dictionary with keys of block number, values of block heights.
densities = (
{}
) # Dictionary with keys of block number, values of dictionaries with keys of nuclide, values of block nuclide density
for i, b in enumerate(self.Assembly):
heights[i] = b.getHeight()
densities[i] = {}
for nuc, dens in b.getNumberDensities().items():
densities[i][nuc] = dens
self.Assembly.axiallyExpandBlockHeights(heightList, adjustList)
for i, b in enumerate(self.Assembly):
# Check height
if i == 0:
ref = heights[i]
elif i == 4:
ref = heights[i] - (expandFrac - 1) * 3 * heights[i]
else:
ref = heights[i] * expandFrac
cur = b.getHeight()
places = 6
self.assertAlmostEqual(cur, ref, places=places)
# Check densities
for nuc, dens in b.getNumberDensities().items():
if (i == 0) or (i == 4):
ref = densities[i][nuc]
else:
ref = densities[i][nuc] / expandFrac
cur = b.getNumberDensity(nuc)
places = 6
self.assertAlmostEqual(cur, ref, places=places)
