def bumat_search(element='94', bu_specific_file_name=file_name + burnup_adder):
'''
Finds values for the element given in bumat file provided
Input: element where element is string number representing the atomic number
Input: bu_file where the file is the current bumat file being analyzed
Output: List of values associated with each of the isotopes of the elements given
'''
global divisions
bu_file = st.read(bu_specific_file_name, 'bumat')
iso_dict = {}
cur_dict_list = []
bu = bu_file.materials
name_conv = list(bu)[-1].strip('1')
divisions = int(list(bu)[0].strip(name_conv))
for radius in range(len(list(bu))):
counter = 0
radial_name = name_conv + str(radius + 1) # 1 is the innermost ring
nuclides = bu.get(radial_name).get('nuclides')
ele_key_list = list(nuclides)
first = True
for ele_list in ele_key_list:
if ele_list.startswith(element):
cur_iso_key = ele_key_list[counter]
try:
cur_dict_list = iso_dict[cur_iso_key]
except:
cur_dict_list = []
cur_dict_list.append(nuclides[cur_iso_key])
iso_dict[cur_iso_key] = cur_dict_list
counter += 1
else:
counter += 1
return iso_dict
def readDataFile(path, **kwargs):
"""
Return a reader for the data file (test or example) file.
All additional keyword arguments will be passed to
:func:`serpentTools.read`.
Parameters
----------
path: str
The name of the file without any additional directory
information
Returns
-------
object
The reader that has processed this file and stored
all the data
Raises
------
IOError:
If the file for ``path`` does not exist
See Also
--------
* :func:`serpentTools.read`
"""
if not exists(path):
# assume this is a example/test file contained in this project
filePath = getFile(path)
else:
_warnDataFilePurpose()
filePath = path
return read(filePath, **kwargs)
def plots_fullcore():
'''
Plots full-core flux detectors:
* Spectrum
* Axial1, Axial2, Axial3,
* Radial1, Radial2, Radial3
'''
# Plot spectrum
data = st.read('serpent/fullcore_det1b1.m', reader='det')
name = 'EnergyDetector'
plot_spectrum(data, name, 'figures2/fullcore')
A = 18/np.cos(np.pi/6) # cm length of face of the hexagon
Ah = 6. * (A * 18./2) # Area of the hexagon
V = Ah * (160 + 793 + 120)
plot_detector(data, 'Axial1', 'figures2/fullcore', V)
plot_detector(data, 'Axial2', 'figures2/fullcore', V)
plot_detector(data, 'Axial3', 'figures2/fullcore', V)
H = 793
p = 2*np.pi # = 360 deg
plot_radial(data, 'Radial1', 'figures2/fullcore', p*H)
H = 79.3
p = np.pi/90 # = 2 deg
plot_radial(data, 'Radial2', 'figures2/fullcore', p*H)
H = 79.3
p = np.pi/90 # = 2 deg
plot_radial(data, 'Radial3', 'figures2/fullcore', p*H)
def test_multipleGcuNoBu(multipleGcuNoBu):
r = serpentTools.read(multipleGcuNoBu)
assert len(r.universes) == 3
for key in r.universes:
assert key.step == 0
assert key.burnup == 0
assert key.days == 0
def __init__(self, leakageCorrection, transportCorrection, solver,
inputFilesAndTemps, outputFile):
rc.__setitem__("serpentVersion", "2.1.30")
self.leakageCorrection = leakageCorrection
self.transportCorrection = transportCorrection
self.solver = solver
self.inputFilesAndTemps = inputFilesAndTemps
self.outputFile = outputFile
self.serpentFilesAndTemps = {}
self.mesh = Mesh()
self.prepareSerpentFiles()
self.fileObject = open(self.outputFile, 'w')
self.printHeader()
for temp in self.serpentFilesAndTemps:
res = serpentTools.read(self.serpentFilesAndTemps[temp])
if temp == list(self.serpentFilesAndTemps.keys())[0]:
self.createMaterials(res)
self.readSerpentOutput(res, temp)
self.calculateALMOSTCrossSections()
self.printAlmostOutput()
def test_2132_nofilter(fake2132File):
with serpentTools.settings.rc as rc:
rc["serpentVersion"] = "2.1.32"
reader = serpentTools.read(fake2132File)
singleFima = numpy.array([0, 0, 1e25])
assert "fima" in reader.resdata
assert (reader.resdata["fima"] == singleFima).all(), reader.resdata["fima"]
assert not reader.resdata["burnRandomizeData"].any()
def test_2132_filterburnup(fake2132File):
with serpentTools.settings.rc as rc:
rc["serpentVersion"] = "2.1.32"
rc["xs.variableGroups"] = ["burnup-coeff", "eig"]
reader = serpentTools.read(fake2132File)
assert "fima" in reader.resdata
assert "burnDays" in reader.resdata
assert "absKeff" in reader.resdata
assert "pop" not in reader.metadata
def _scrape(self, resfile):
"""Read multiplication factor from resfile"""
try:
reader = read(resfile, 'results')
kinf = reader.resdata['absKeff'][0:2]
except Exception as ee:
move(resfile, self._pwd)
raise ee
return kinf
def plots_standardcolumn():
"""
Plots standard-column flux detector
"""
data = st.read('standard-column_det0.m', reader='det')
A = 18/np.cos(np.pi/6) # cm length of face of the hexagon
Ah = 6. * (A * 18./2) # Area of the hexagon
V = Ah * (160 + 793 + 120)
plot_detector(data, 'Axial', V)
def get_keff_vs_bu(filename):
'''
'''
data = st.read(filename + '_res.m')
keff = data.resdata['impKeff'][:, 0]
days = data.resdata['burnDays'][:, 0]
# plt.figure()
# plt.plot(days, keff, marker='o')
# plt.xlabel('EFFPD')
# plt.ylabel('Keff')
# plt.savefig('keff-vs-bu', dpi=300, bbox_inches="tight")
# plt.close()
return keff[-1]
def get_power(self, filename, detectorname):
data = st.read(filename, reader='det')
det = data.detectors[detectorname]
self.power = []
# 1
self.power.append(det.tallies[0, 7])
self.power.append(det.tallies[0, 8])
# 2
self.power.append(det.tallies[1, 5])
self.power.append(det.tallies[1, 6])
self.power.append(det.tallies[1, 8])
self.power.append(det.tallies[1, 9])
# 3
self.power.append(det.tallies[2, 6])
self.power.append(det.tallies[2, 7])
self.power.append(det.tallies[2, 9])
self.power.append(det.tallies[2, 10])
# 4
self.power.append(det.tallies[3, 5])
self.power.append(det.tallies[3, 7])
self.power.append(det.tallies[3, 8])
self.power.append(det.tallies[3, 10])
# 5
self.power.append(det.tallies[4, 5])
self.power.append(det.tallies[4, 6])
self.power.append(det.tallies[4, 8])
self.power.append(det.tallies[4, 9])
# 6
self.power.append(det.tallies[5, 6])
self.power.append(det.tallies[5, 7])
self.power.append(det.tallies[5, 9])
# 7
self.power.append(det.tallies[6, 5])
self.power.append(det.tallies[6, 7])
self.power.append(det.tallies[6, 8])
# 8
self.power.append(det.tallies[7, 5])
self.power.append(det.tallies[7, 6])
self.power.append(det.tallies[7, 8])
# 9
self.power.append(det.tallies[8, 6])
self.power.append(det.tallies[8, 7])
# 10
self.power.append(det.tallies[9, 5])
# 11
#
self.power = np.array(self.power)
def ReadPdistrHistSerpent(file, FullCoreLayout):
SerpentLayout = GetSerpentLayout(FullCoreLayout, 2)
# Read that Serpent history file
hist = serpentTools.read(file)
# For a detector (here -80), the results are grouped in three columns that
# provide (1) the cycle-wise value,
# (2) the cumulative mean and
# (3) the corresponding relative statistical error.
# Cf. http://serpent.vtt.fi/mediawiki/index.php/Description_of_output_files#History_output
# Only the first is kept here.
cycle = hist['det-80'][:, 0::3]
# Among that, only the total deposited energy is kept
cycle = cycle[:, 0::3]
# Among that, only the central layer (the active core) is kept ; top and
# bottom layers are splitted out
cycle = np.split(cycle, 3, axis=1)[1]
# Raise exception if inactive generations are being used. One (1) inactive
# generation is the minimum permitted by Serpent and therefore the only
# one we accept.
if np.isclose(0.0, np.sum(cycle[1]), atol=1e-20):
raise Exception('The convergence plot cannot be achieved since ' +
'inactive generations have been detected: ' +
'*set pop [x] [y] 1* should be used in Serpent.')
# Reshaping into nbatch*size*size
nbatch = np.shape(cycle)[0]
nxysize = int(math.sqrt(np.shape(cycle)[1]))
cycle.shape = (nbatch, nxysize, nxysize)
# Prepare output
out = np.zeros((nbatch, np.count_nonzero(FullCoreLayout)))
for ibatch in range(1, nbatch):
# Filter out the reflector to get only the response of the core
thiscycle = np.where(SerpentLayout == 0, 0, cycle[ibatch])
# Normalize the core power
nassembly = np.count_nonzero(FullCoreLayout)
thiscycle = nassembly * thiscycle / np.sum(thiscycle)
# Remove columns and rows full of zeroes
thiscycle = Deploy2D(thiscycle[np.nonzero(thiscycle)], FullCoreLayout)
# The input is symmetrical by eighth, so we can symmetrize (a fold
# followed by an unfold) in order to increase the statistical strength
thiscycle = UnfoldEighth(FoldEighth(thiscycle))
# Keep all the (non-zero) powers of the full core
out[ibatch] = thiscycle[np.nonzero(thiscycle)]
# ... except the first (empty) one (it is the only inactive generation)
return out[1:]
def get_calculated_values(self) -> bool:
'Fill k and cr for lattice if calculated'
if os.path.exists(self.deck_path+'/done.out') and \
os.path.getsize(self.deck_path+'/done.out') > 30:
pass
else: # Calculation not done yet
return False
results = serpentTools.read(self.deck_path + '/' + self.deck_name +
"_res.m")
self.k = results.resdata["anaKeff"][0]
self.kerr = results.resdata["anaKeff"][1]
self.cr = results.resdata["conversionRatio"][0]
self.crerr = results.resdata["conversionRatio"][1]
if my_debug:
print("[DEBUG Lat] ---> k = {self.k}, CR = {self.cr}".format(
**locals()))
return True
def get_power(self, filename, detectorname):
data = st.read(filename, reader='det')
det = data.detectors[detectorname]
self.power = []
# 1
# 2
# 3
# 4
self.power.append(det.tallies[3, 2])
# 5
self.power.append(det.tallies[4, 2])
self.power.append(det.tallies[4, 3])
# 6
self.power.append(det.tallies[5, 1])
self.power.append(det.tallies[5, 3])
# 7
self.power.append(det.tallies[6, 1])
self.power.append(det.tallies[6, 2])
# 8
self.power.append(det.tallies[7, 0])
self.power.append(det.tallies[7, 2])
self.power.append(det.tallies[7, 3])
self.power.append(det.tallies[7, 5])
self.power.append(det.tallies[7, 6])
# 9
self.power.append(det.tallies[8, 0])
self.power.append(det.tallies[8, 1])
self.power.append(det.tallies[8, 3])
self.power.append(det.tallies[8, 4])
self.power.append(det.tallies[8, 6])
self.power.append(det.tallies[8, 7])
# 10
self.power.append(det.tallies[9, 1])
self.power.append(det.tallies[9, 2])
self.power.append(det.tallies[9, 4])
self.power.append(det.tallies[9, 5])
# 11
self.power.append(det.tallies[10, 2])
self.power.append(det.tallies[10, 3])
#
self.power = np.array(self.power)
def main():
# Serpent results
# Add legend to geometry figure
# standard()
# Plot flux
data = st.read('standard-column_det0.m', reader='det')
save = 'standard-column-detector'
A = 18 / np.cos(np.pi / 6) # cm length of face of the hexagon
Ah = 6. * (A * 18. / 2) # Area of the hexagon
V = Ah * (160 + 793 + 120)
# plot_serpent_axial(data, 'Axial', save, V)
plot_serpent_axial_werrbars(data, 'Axial', save, V)
# Moltres results
# Add legend to geometry figure
# moltres_assembly_legend()
# Plot flux
file = '3D-assembly-h**o-eig_fuel_0002.csv'
save = 'standard-column-h**o'
plotcsv_frommoose_groups(file, save, G=2, dire='z')
def ReadPdistrSerpent(file, FullCoreLayout, msg):
# Retrieve Serpent detector output
det = serpentTools.read(file)
# Total energy deposition, see
# http://serpent.vtt.fi/mediawiki/index.php/ENDF_reaction_MT%27s_and_macroscopic_reaction_numbers
reaction = '-80'
power = det.detectors[reaction].tallies
if reaction == '-80':
power = power[0]
# Number of assembly-sized tallies outside the core, on each side
outside = 2
# Produce the core layout corresponding to tallies
hstack = np.zeros((len(FullCoreLayout), outside))
TalliesLayout = np.hstack([hstack, FullCoreLayout, hstack])
vstack = np.zeros((outside, len(FullCoreLayout) + 2 * outside))
TalliesLayout = np.vstack([vstack, TalliesLayout, vstack])
# Compute fraction of power delivered in the reflector
corepower = np.where(TalliesLayout == 0, 0, power[1])
radialreflpower = np.where(TalliesLayout == 1, 0, power[1])
botreflpower = np.sum(power[0])
topreflpower = np.sum(power[2])
reflpower = np.sum(radialreflpower) + botreflpower + topreflpower
print('Fraction of the power Serpent delivers in the reflector = ' +
str(np.sum(reflpower) / np.sum(power)) + ' (' + msg + ')')
# Ignore reflector power and renormalize core power
corepower = corepower / np.sum(corepower) * np.count_nonzero(corepower)
# The input is symmetrical by eighth, so we can symmetrize (a fold followed
# by an unfold) in order to increase the statistical strength
symcorepower = UnfoldEighth(FoldEighth(corepower))
# Estimate the uncertainty
sym = symcorepower
unsym = corepower
reldif = unsym[np.nonzero(unsym)] / sym[np.nonzero(sym)] - 1
print("min, max (%)=" + str(np.min(reldif) * 100) + ", " +
str(np.max(reldif) * 100))
# Return powers, removing all of them equal to zero
return symcorepower[np.nonzero(symcorepower)]
import matplotlib.pyplot as plt
from matplotlib.cbook import get_sample_data
import serpentTools as st
import pathmagic
from auxiliary import plot_serpent_axial_collapse
if __name__ == "__main__":
A = 18/np.cos(np.pi/6) # cm length of face of the hexagon
Ah = 6. * (A * 18./2) # Area of the hexagon
V = Ah * (160 + 793 + 120)
lim = [4, 16, 26]
name = 'Axial'
data = st.read('standard-column-noLBP-26G_det1b1.m', reader='det')
save = 'serpent26G-noLBP-600-collapse'
plot_serpent_axial_collapse(data, name, save, lim, V)
data = st.read('standard-column-noLBP-26G_det1b3.m', reader='det')
save = 'serpent26G-noLBP-1200-collapse'
plot_serpent_axial_collapse(data, name, save, lim, V)
data = st.read('standard-column-LBP-26G_det1b1.m', reader='det')
save = 'serpent26G-LBP-600-collapse'
plot_serpent_axial_collapse(data, name, save, lim, V)
data = st.read('standard-column-LBP-26G_det1b3.m', reader='det')
save = 'serpent26G-LBP-1200-collapse'
plot_serpent_axial_collapse(data, name, save, lim, V)
from numpy import empty
from itertools import product
import serpentTools
d = serpentTools.read('det_det0.m')['xymesh']
# Get data
xgrids = d.grids['X']
ygrids = d.grids['Y']
nx = xgrids.shape[0]
ny = ygrids.shape[0]
data = empty((nx * ny, 4))
data[:, 2].fill(0)
for ix, (yi, xi) in enumerate(product(range(ny), range(nx))):
data[ix, 0] = xgrids[xi, 2]
data[ix, 1] = ygrids[yi, 2]
data[ix, 3] = d.tallies[yi, xi]
with open('det.csv', 'w') as out:
out.write("X Axis,Y Axis,Z Axis,Flux\n")
for row in data:
out.write(','.join(map(str, row)) + "\n")
strData = materials[currentMat][data]
strData = ' '.join([str(dat)
for dat in strData]) if isinstance(
strData, np.ndarray) else str(strData)
fh.write(str(temp) + ' ' + strData)
fh.write('\n')
return None
if __name__ == '__main__':
'''
Cross-sections from 'fullcore3G-LBP.coe' - 9 176 (fuel).
'''
# get data from .coe
coeList = sT.read('fullcore3G-LBP.coe')
# user defined parameters
mat = 'fuel'
item = 'fuel0'
uni = '9'
getdata = [
'Flx', 'Tot', 'Sp0', 'Sp2', 'Fiss', 'Nsf', 'Kappa', 'Sp1', 'Sp3',
'Invv', 'Chit', 'Chip', 'Chid', 'Diffcoef', 'Abs'
]
goodMap = dict([(thing, 'inf' + thing) for thing in getdata])
constants = {}
for data in getdata:
constants[data.upper()] = coeList.branches[item].universes[
cur_iso_key = ele_key_list[counter]
try:
cur_dict_list = iso_dict[cur_iso_key]
except:
cur_dict_list = []
cur_dict_list.append(nuclides[cur_iso_key])
iso_dict[cur_iso_key] = cur_dict_list
counter += 1
else:
counter += 1
return iso_dict
##### File Reading
try:
depf = st.read(file_name + depletion_adder, 'dep')
depletion_file = True
except:
depletion_file = False
print('No depletion file found.')
try:
resf = st.read(file_name + results_adder, 'results')
result_file = True
except:
result_file = False
print('No result file found.')
if depletion_file:
##### Defining Materials
dep_fuel = depf.materials['uranium']
def test_similarDetectors(similarDetectorFile):
reader = serpentTools.read(similarDetectorFile)
assert set(reader.detectors) == {"spectrum", "spectrumA", "spectrumB"}
assert isinstance(reader["spectrumA"], detectors.HexagonalDetector)
SerpentLayout = GetSerpentLayout(FullCoreLayout, 2)
for file in glob.glob('../Serpent/BatchHist/Tihange*ppm_*.sss2_his0.m'):
print(file)
# Identify the file we're about to read
basename = file.split('/')[-1].split('.')[0]
cbor = int(re.sub("[^0-9]", "", basename.split('_')[0]))
if cbor == 1206:
controlrod = 'ARO'
elif cbor == 1084:
controlrod = 'D'
elif cbor == 960:
controlrod = 'CD'
else:
raise Exception(cbor + ' unknown.')
# Read that Serpent history file
hist = serpentTools.read(file)
# For a detector (here -80), the results are grouped in three columns that
# provide (1) the cycle-wise value,
# (2) the cumulative mean and
# (3) the corresponding relative statistical error.
# Cf. http://serpent.vtt.fi/mediawiki/index.php/Description_of_output_files#History_output
# Only the first is kept here.
cycle = hist['det-80'][:, 0::3]
# Among that, only the total deposited energy is kept
cycle = cycle[:, 0::3]
# Among that, only the central layer (the active core) is kept ; top and
# bottom layers are splitted out
cycle = np.split(cycle, 3, axis=1)[1]
# Raise exception if inactive generations are being used. One (1) inactive
# generation is the minimum permitted by Serpent and therefore the only
# one we accept.
print("Submitting File ",i)
print("-----Files Submitted!-----")
for i,enrichment in enumerate(enrichments):
prefix="godiva"
prefix+="{:0>2d}".format(i)
file_in=prefix+".inp"
file_out=prefix+".out"
resname=file_in+"_res.m"
while resname not in glob.glob("*_res.m"):
time.sleep(10)
print("Files Still Running, Waiting Ten Seconds")
results=serpentTools.read(resname)
keff_sigma=results.resdata['absKeff'] #keff with sigma
keff=results.resdata['absKeff'][0] #keff
keff_list.append(keff)
with open("godiva_data.csv","a+") as datafile:
datafile.write("{},{},{},{}\n".format(file_in,enrichment,radius,keff))
print("-----Done!-----")
# Open results file
results = openmc.deplete.ResultsList.from_hdf5("openmc/depletion_results.h5")
# Obtain K_eff as a function of time
time, keff = results.get_eigenvalue()
# Obtain concentration as a function of time
time, atoms = results.get_atoms('1', nuc)
radius = 0.39218
volume = pi * radius**2
openmc_conc = atoms * 1e-24 / volume # [atoms] [cm^2/b] / [cm^2] = atom/b
# Read Serpent results --------------------------------------------------------
sdata = serpentTools.read('serpent/serpent_input_dep.m')
fuel = sdata['fuel']
serpent_days = fuel.days
serpent_conc = fuel.getValues(
'days', 'adens', names=f'{ATOMIC_SYMBOL[z]}{a}{"m" if m else ""}')[0]
# Plot results ----------------------------------------------------------------
fig, ax = plt.subplots()
day = 24 * 60 * 60
ax.plot(time / day, openmc_conc, 'kx', label=f"{nuc} (OpenMC)")
ax.plot(serpent_days, serpent_conc, 'b-', label=f"{nuc} (Serpent)")
ax.set_xlabel("Time (days)")
ax.set_ylabel("Atom/barn")
ax.legend()
ax.grid(True, which='both')
plt.ylabel('Y [cm]')
plt.savefig(save, dpi=300, bbox_inches="tight")
plt.close()
if __name__ == "__main__":
lim26 = [4, 16, 26] # collapse from 26 to 3
A = 18/np.cos(np.pi/6) # cm length of face of the hexagon
Ah = 6. * (A * 18./2) # Area of the hexagon
V = Ah * (160 + 793 + 120)
H = 79.3
p = np.pi/180 * 2 # = 2 deg
# plot axial and radial flux at 600K
data = st.read('oecd-fullcore-600_det1b1.m', reader='det')
save = 'serpent26G-600-collapse-Axial1'
plot_serpent_axial_collapse(data, 'Axial1', save, lim26, V, 'Z')
save = 'serpent26G-600-collapse-Radial'
plot_serpent_radial_collapse(data, 'Radial3', save, lim26, p*H)
# plot serpent radial power distribution 600K
det = data.detectors['power']
power = np.zeros(11)
power[0] = det.tallies[0, 3]
power[1] = det.tallies[0, 4]
power[2] = det.tallies[1, 2]
power[3] = det.tallies[1, 3]
power[4] = det.tallies[1, 4]
power[5] = det.tallies[2, 1]
power[6] = det.tallies[2, 2]
def makePropertiesDir(outdir,
filebase,
mapFile,
secbranchFile,
unimapFile,
serp1=False,
fromMain=False):
""" Takes in a mapping from branch names to material temperatures,
then makes a properties directory.
Serp1 means that the group transfer matrix is transposed."""
if serp1:
raise NotImplementedError("C'mon, just get serpent 2!")
if not os.path.isdir(outdir):
os.mkdir(outdir)
# the constants moltres looks for:
goodStuff = [
'BETA_EFF', 'Chit', 'Chid', 'lambda', 'Diffcoef', 'Kappa', 'Sp0',
'Nsf', 'Invv', 'Remxs', 'Fiss', 'Nubar', 'Flx'
]
goodMap = dict([(thing, 'inf' + thing) for thing in goodStuff])
goodMap['BETA_EFF'] = 'betaEff'
goodMap['lambda'] = 'lambda'
# map material names to universe names from serpent
with open(unimapFile) as fh:
uniMap = []
for line in fh:
uniMap.append(tuple(line.split()))
# this now maps material names to serpent universes
uniMap = dict(uniMap)
# list of material names
inmats = list(uniMap.keys())
print("Making properties for materials:")
print(inmats)
coeList = dict([(mat, sT.read(mat + '.coe')) for mat in inmats])
# secondary branch burnup steps
secBranch = []
with open(secbranchFile) as bf:
for line in bf:
secBranch.append(line)
# primary branch to temp mapping
branch2TempMapping = open(mapFile)
# Check if calculation uses 6 neutron precursor groups.
# This prevents writing of excess zeros. Check if any
# entries in the 7th and 8th group precursor positions
# are nonzero, if so, use 8 groups.
use8Groups = False
for line in branch2TempMapping:
item, temp = tuple(line.split())
for mat in inmats:
if mat in item:
currentMat = mat
break
if secBranch:
for branch in secBranch:
strData = coeList[currentMat].branches[item, branch].universes[
int(uniMap[currentMat]), 0, 0].gc[goodMap['BETA_EFF']]
strData = strData[1:9]
if np.any(strData[-2:] != 0.0):
use8Groups = True
else:
strData = coeList[currentMat].branches[item].universes[
int(uniMap[currentMat]), 0, 0].gc[goodMap['BETA_EFF']]
strData = strData[1:9]
if np.any(strData[-2:] != 0.0):
use8Groups = True
# Now loop through a second time
branch2TempMapping.close()
branch2TempMapping = open(mapFile)
for line in branch2TempMapping:
item, temp = tuple(line.split())
for mat in inmats:
if mat in item:
currentMat = mat
break
else:
print('Considered materials: {}'.format(inmats))
raise Exception(
'Couldnt find a material corresponding to branch {}'.format(
item))
try:
if secBranch:
for branch in secBranch:
for coefficient in goodStuff:
with open(
outdir + '/' + filebase + '_' + currentMat +
'_' + branch + '_' + coefficient.upper() +
'.txt', 'a') as fh:
if coefficient == 'lambda' or \
coefficient == 'BETA_EFF':
strData = coeList[currentMat].branches[
item, branch].universes[
int(uniMap[currentMat]), 0,
0].gc[goodMap[coefficient]]
# some additional formatting is needed here
strData = strData[1:9]
# Cut off group 7 and 8 precursor params in 6
# group calcs
if not use8Groups:
strData = strData[0:6]
else:
strData = coeList[currentMat].branches[
item, branch].universes[
int(uniMap[currentMat]), 0,
0].infExp[goodMap[coefficient]]
strData = ' '.join(
[str(dat) for dat in strData]) if isinstance(
strData, np.ndarray) else strData
fh.write(str(temp) + ' ' + strData)
fh.write('\n')
else:
for coefficient in goodStuff:
with open(
outdir + '/' + filebase + '_' + currentMat + '_' +
coefficient.upper() + '.txt', 'a') as fh:
if coefficient == 'lambda' or \
coefficient == 'BETA_EFF':
strData = coeList[currentMat].branches[
item].universes[int(uniMap[currentMat]), 0,
0].gc[goodMap[coefficient]]
# some additional formatting is needed here
strData = strData[1:9]
# Cut off group 7 and 8 precursor params in 6
# group calcs
if not use8Groups:
strData = strData[0:6]
else:
strData = coeList[currentMat].branches[
item].universes[int(uniMap[currentMat]), 0,
0].infExp[goodMap[coefficient]]
strData = ' '.join(
[str(dat) for dat in strData]) if isinstance(
strData, np.ndarray) else strData
fh.write(str(temp) + ' ' + strData)
fh.write('\n')
except KeyError:
print(secBranch)
raise Exception('Check your mapping and secondary branch files.')
from tabulate import tabulate
from uncertainties import unumpy as unp
# Read OpenMC results ---------------------------------------------------------
# Open results file
results = openmc.deplete.ResultsList.from_hdf5("openmc/depletion_results.h5")
# Obtain K_eff as a function of time
time, k = results.get_eigenvalue()
openmc_keff = unp.uarray(k[:, 0], k[:, 1])
days = time / (24 * 60 * 60)
# Read Serpent results --------------------------------------------------------
res = serpentTools.read('serpent/serpent_input_res.m')
serpent_days = res.resdata['burnDays'][:, 0]
serpent_keff = unp.uarray(res.resdata['absKeff'][:, 0],
res.resdata['absKeff'][:, 1])
# Plot results ----------------------------------------------------------------
# Show tabulation
data = np.vstack((days, serpent_keff, openmc_keff)).T
print(tabulate(data, headers=['Days', 'Serpent', 'OpenMC']))
diff = 1e5 * (openmc_keff - serpent_keff)
fig, ax = plt.subplots()
ax.errorbar(days,
unp.nominal_values(diff),
2 * unp.std_devs(diff),
def read(self, readable, filetype):
"""Read an output file and return the corresponding reader
Wrapper around ``serpentTools.read`` with some extra sugar.
First, and most plainly, if no options are pre-defined
in :attr:`options` for a given file type, then nothing fancy
is done. The file is read and the resulting Reader is
returned. Otherwise, the settings are passed to
``serpentTools`` and reverted after the file is read.
Parameters
----------
readable : str
Name of the file to be read. There should be a
corresponding ``serpentTools`` reader that can handle
this file.
filetype : str
Type of the file, e.g. ``"results"``. While this is
not necessary on the ``serpentTools`` side, it is used
to pull pre-defined options to improve parsing. This
is especially useful for the result file as only
global multiplication factor and locally homogenized
cross sections will be read.
Returns
-------
Reader
serpentTools reader that processed this file
Warns
-----
SyntaxWarning
Will be raised if setting any settings are unable to be
passed into the settings manager. The file will be read
regardless, but a warning will be raised
"""
opts = self.options.get(filetype)
if opts is None:
return serpentTools.read(readable, filetype)
valuefails = {}
unexpectedfails = {}
with serpentTools.settings.rc as temp:
for k, v in opts.items():
try:
temp[k] = v
except (KeyError, TypeError):
valuefails[k] = v
except Exception:
unexpectedfails[k] = v
serpentFile = serpentTools.read(readable, filetype)
if valuefails:
self._warnOptions(valuefails, "Bad settings and/or values")
if unexpectedfails:
self._warnOptions(
unexpectedfails,
"Unexpected failure with rc settings. File parsing still successful",
)
return serpentFile
def get_power(self, filename, detectorname):
data = st.read(filename, reader='det')
det = data.detectors[detectorname]
self.power = []
#
self.power.append(det.tallies[0, 7])
self.power.append(det.tallies[0, 8])
#
self.power.append(det.tallies[1, 5])
self.power.append(det.tallies[1, 6])
self.power.append(det.tallies[1, 8])
self.power.append(det.tallies[1, 9])
#
self.power.append(det.tallies[2, 3])
self.power.append(det.tallies[2, 4])
self.power.append(det.tallies[2, 6])
self.power.append(det.tallies[2, 7])
self.power.append(det.tallies[2, 9])
self.power.append(det.tallies[2, 10])
#
self.power.append(det.tallies[3, 2])
self.power.append(det.tallies[3, 4])
self.power.append(det.tallies[3, 5])
self.power.append(det.tallies[3, 7])
self.power.append(det.tallies[3, 8])
self.power.append(det.tallies[3, 10])
#
self.power.append(det.tallies[4, 2])
self.power.append(det.tallies[4, 3])
self.power.append(det.tallies[4, 5])
self.power.append(det.tallies[4, 6])
self.power.append(det.tallies[4, 8])
self.power.append(det.tallies[4, 9])
#
self.power.append(det.tallies[5, 1])
self.power.append(det.tallies[5, 3])
self.power.append(det.tallies[5, 4])
self.power.append(det.tallies[5, 6])
self.power.append(det.tallies[5, 7])
self.power.append(det.tallies[5, 9])
#
self.power.append(det.tallies[6, 1])
self.power.append(det.tallies[6, 2])
self.power.append(det.tallies[6, 4])
self.power.append(det.tallies[6, 5])
self.power.append(det.tallies[6, 7])
self.power.append(det.tallies[6, 8])
#
self.power.append(det.tallies[7, 0])
self.power.append(det.tallies[7, 2])
self.power.append(det.tallies[7, 3])
self.power.append(det.tallies[7, 5])
self.power.append(det.tallies[7, 6])
self.power.append(det.tallies[7, 8])
#
self.power.append(det.tallies[8, 0])
self.power.append(det.tallies[8, 1])
self.power.append(det.tallies[8, 3])
self.power.append(det.tallies[8, 4])
self.power.append(det.tallies[8, 6])
self.power.append(det.tallies[8, 7])
#
self.power.append(det.tallies[9, 1])
self.power.append(det.tallies[9, 2])
self.power.append(det.tallies[9, 4])
self.power.append(det.tallies[9, 5])
#
self.power.append(det.tallies[10, 2])
self.power.append(det.tallies[10, 3])
self.power = np.array(self.power)
#!/usr/bin/env python3 # # Read & Plot flux along X direction, Goofing with Godiva mk2 # Ondrej Chvala, [email protected] # 2019-07-22 import matplotlib.pyplot as plt import numpy as np import serpentTools verbose: bool = True # Read in data godivafile = serpentTools.read("godiva.inp_det0.m") mydet = godivafile['mydet'] # Fill simple arrays for convenient plotting xdata = mydet.grids['X'][:, 2] # centers of X bins [cm] thrmflux = mydet.slice({'energy': 0}) # THERMAL FLUX thrmfluxe = mydet.slice({'energy': 0}, 'errors') thrmfluxe *= thrmflux # relative -> absolute errors epitflux = mydet.slice({'energy': 1}) # EPITHERMAL FLUX epitfluxe = mydet.slice({'energy': 1}, 'errors') epitfluxe *= epitflux # relative -> absolute errors fastflux = mydet.slice({'energy': 2}) # FAST FLUX fastfluxe = mydet.slice({'energy': 2}, 'errors') fastfluxe *= fastflux # relative -> absolute errors if verbose: print("XDATA: ", xdata) print("FAST FLUX: ", fastflux)
