def toENDF6(self, flags, targetInfo, verbosityIndent=''):
gridded = self.forms[0]
data = gridded.array.constructArray()
Tlist = list(gridded.axes[-1].grid) #FIXME what if grid units aren't 'K'?
Elist = list(gridded.axes[-2].grid) #FIXME "" 'eV'?
LT = len(Tlist) - 1
# first temperature includes the energy list:
endf = [
endfFormatsModule.endfHeadLine(Tlist[0], 0, LT, 0, 1, len(data[0]))
]
independentInterp = gndToENDF6.gndToENDFInterpolationFlag(
gridded.axes[1].interpolation)
dependentInterp = gndToENDF6.gndToENDFInterpolationFlag(
gridded.axes[2].interpolation)
endf += ['%11i%11i%44s' % (len(data[0]), independentInterp, '')
] # no trailing zeros
endf += endfFormatsModule.endfDataList(
list(itertools.chain(*zip(Elist, data[0]))))
# remaining temperatures:
for T, datList in zip(Tlist[1:], data[1:]):
endf += [
endfFormatsModule.endfHeadLine(T, 0, dependentInterp, 0,
len(datList), 0)
]
endf += endfFormatsModule.endfDataList(datList)
return endf
def toENDF6(self, flags, targetInfo, verbosityIndent=''):
NR = 1
NP = len(self)
endf = [endfFormatsModule.endfHeadLine(0, 0, 0, 0, NR, NP)]
interp = gndToENDF6.gndToENDFInterpolationFlag(self.interpolation)
endf += ['%11i%11i%44s' % (len(self), interp, '')]
endf += endfFormatsModule.endfDataList(
list(itertools.chain(*self.copyDataToXYs())))
return endf
def toENDF6(self, endfMFList, flags, targetInfo, verbosityIndent=''):
ZAM, AWT = targetInfo['ZA'], targetInfo['mass']
LTHR, LAT, LASYM = 0, self.calculatedAtThermal, self.asymmetric
endf = [endfFormatsModule.endfHeadLine(ZAM, AWT, LTHR, LAT, LASYM, 0)]
# describe scattering atoms:
LLN, NS = 0, len(self.scatteringAtoms) - 1
NI = 6 * (NS + 1)
endf += [endfFormatsModule.endfHeadLine(0, 0, LLN, 0, NI, NS)]
# principal scattering atom:
atom = self.scatteringAtoms[0]
endf += [
endfFormatsModule.endfDataLine([
atom.freeAtomCrossSection.getValueAs('b'), atom.e_critical,
atom.mass,
atom.e_max.getValueAs('eV'), 0, atom.numberPerMolecule
])
]
for atom in self.scatteringAtoms[1:]:
a1 = {
'SCT': 0.0,
'free_gas': 1.0,
'diffusive_motion': 2.0
}[atom.functionalForm]
endf += [
endfFormatsModule.endfDataLine([
a1,
atom.freeAtomCrossSection.getValueAs('b'), atom.mass, 0, 0,
atom.numberPerMolecule
])
]
# convert data form: sort first by beta, then E, then T
gridded = self.S_alpha_beta.forms[0]
array = gridded.array.constructArray() # 3D numpy array
Tlist = list(gridded.axes[3].grid) # FIXME check grid units
betas = list(gridded.axes[2].grid)
alphas = list(gridded.axes[1].grid)
# switch array back to ENDF ordering: 1st beta, then T, then alpha:
array = array.transpose((1, 0, 2))
NR = 1
NB = len(betas)
endf += [endfFormatsModule.endfHeadLine(0, 0, 0, 0, NR, NB)]
#endf += endfFormatsModule.endfInterpolationList( (NB, 4) )
endf += [
'%11i%11i%44s' % (NB, 4, '')
] # FIXME add 'suppressTrailingZeros' option to endfInterpolationList
LT = len(Tlist) - 1
if LT:
T_interp = gndToENDF6.gndToENDFInterpolationFlag(
gridded.axes[3].interpolation)
else:
T_interp = None
beta_interp = gndToENDF6.gndToENDFInterpolationFlag(
gridded.axes[2].interpolation)
alpha_interp = gndToENDF6.gndToENDFInterpolationFlag(
gridded.axes[1].interpolation)
for index, beta in enumerate(betas):
data = array[index, :, :] # 2D sub-array for this beta
endf += [
endfFormatsModule.endfHeadLine(Tlist[0], beta, LT, 0, 1,
len(data[0]))
]
endf += ['%11i%11i%44s' % (len(alphas), alpha_interp, '')
] # no trailing zeros
# For each beta, the first temperature needs to include the energy list:
endf += endfFormatsModule.endfDataList(
list(itertools.chain(*zip(alphas, data[0]))))
# remaining temperatures:
for T, datList in zip(Tlist[1:], data[1:]):
endf += [
endfFormatsModule.endfHeadLine(T, beta, T_interp, 0,
len(datList), 0)
]
endf += endfFormatsModule.endfDataList(datList)
for atom in self.scatteringAtoms:
if atom.effectiveTemperature is not None:
endf += atom.effectiveTemperature.toENDF6(flags,
targetInfo,
verbosityIndent='')
endfMFList[7][4] = endf + [99999]
def toENDF6(self, flags, targetInfo, verbosityIndent=''):
endf = []
AP = self.scatteringRadius
if AP.isEnergyDependent():
scatRadius = AP.form
NR, NP = 1, len(scatRadius)
endf.append(endfFormatsModule.endfHeadLine(0, 0, 0, 0, NR, NP))
endf += endfFormatsModule.endfInterpolationList(
(NP,
gndToENDF6.gndToENDFInterpolationFlag(scatRadius.interpolation)))
endf += endfFormatsModule.endfNdDataList(
scatRadius.convertAxisToUnit(0, '10*fm'))
AP = 0
else:
AP = AP.getValueAs('10*fm')
NLS = len(self.L_values)
LFW = targetInfo['unresolved_LFW']
LRF = targetInfo['unresolved_LRF']
def v(val): # get value back from PhysicalQuantityWithUncertainty
if type(val) == type(None): return
return val.getValueAs('eV')
if LFW == 0 and LRF == 1: # 'Case A' from ENDF 2010 manual pg 70
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['spin'], AP,
self.forSelfShieldingOnly, 0, NLS,
0))
for Lval in self.L_values:
NJS = len(Lval.J_values)
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['mass'], 0, Lval.L,
0, 6 * NJS, NJS))
for Jval in Lval.J_values:
# here we only have one width per J:
ave = Jval.constantWidths
endf.append(
endfFormatsModule.endfDataLine([
v(ave.levelSpacing), Jval.J.value, Jval.neutronDOF,
v(ave.neutronWidth),
v(ave.captureWidth), 0
]))
elif LFW == 1 and LRF == 1: # 'Case B'
energies = self.L_values[0].J_values[
0].energyDependentWidths.getColumn('energy', units='eV')
NE = len(energies)
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['spin'], AP,
self.forSelfShieldingOnly, 0, NE,
NLS))
nlines = int(math.ceil(NE / 6.0))
for line in range(nlines):
endf.append(
endfFormatsModule.endfDataLine(energies[line * 6:line * 6 +
6]))
for Lval in self.L_values:
NJS = len(Lval.J_values)
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['mass'], 0, Lval.L,
0, NJS, 0))
for Jval in Lval.J_values:
cw = Jval.constantWidths
endf.append(
endfFormatsModule.endfHeadLine(0, 0, Lval.L,
Jval.fissionDOF, NE + 6, 0))
endf.append(
endfFormatsModule.endfDataLine([
v(cw.levelSpacing), Jval.J.value, Jval.neutronDOF,
v(cw.neutronWidth),
v(cw.captureWidth), 0
]))
fissWidths = Jval.energyDependentWidths.getColumn(
'fissionWidthA', units='eV')
for line in range(nlines):
endf.append(
endfFormatsModule.endfDataLine(
fissWidths[line * 6:line * 6 + 6]))
elif LRF == 2: # 'Case C', most common in ENDF
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['spin'], AP,
self.forSelfShieldingOnly, 0, NLS,
0))
INT = gndToENDF6.gndToENDFInterpolationFlag(self.interpolation)
for Lval in self.L_values:
NJS = len(Lval.J_values)
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['mass'], 0, Lval.L,
0, NJS, 0))
for Jval in Lval.J_values:
NE = len(Jval.energyDependentWidths)
useConstant = not NE
if useConstant: NE = 2
endf.append(
endfFormatsModule.endfHeadLine(Jval.J.value, 0, INT, 0,
6 * NE + 6, NE))
endf.append(
endfFormatsModule.endfDataLine([
0, 0, Jval.competitiveDOF, Jval.neutronDOF,
Jval.gammaDOF, Jval.fissionDOF
]))
cws = Jval.constantWidths
if useConstant:
# widths are all stored in 'constantWidths' instead. get energies from parent class
NE = 2
useConstant = True
eLow, eHigh = targetInfo['regionEnergyBounds']
for e in (eLow, eHigh):
endf.append(
endfFormatsModule.endfDataLine([
v(e),
v(cws.levelSpacing),
v(cws.competitiveWidth),
v(cws.neutronWidth),
v(cws.captureWidth),
v(cws.fissionWidthA)
]))
else:
table = [
Jval.energyDependentWidths.getColumn('energy',
units='eV')
]
for attr in ('levelSpacing', 'competitiveWidth',
'neutronWidth', 'captureWidth',
'fissionWidthA'):
# find each attribute, in energy-dependent or constant width section
column = (Jval.energyDependentWidths.getColumn(
attr, units='eV') or [v(getattr(cws, attr))] * NE)
if not any(column): column = [0] * NE
table.append(column)
for row in zip(*table):
endf.append(endfFormatsModule.endfDataLine(row))
return endf
def toENDF6(self, flags, targetInfo, verbosityIndent=''):
endf = []
AP = getattr(self, 'scatteringRadius')
if AP.isEnergyDependent():
scatRadius = AP.form
NR, NP = 1, len(scatRadius)
endf.append(endfFormatsModule.endfHeadLine(0, 0, 0, 0, NR, NP))
endf += endfFormatsModule.endfInterpolationList(
(NP,
gndToENDF6.gndToENDFInterpolationFlag(scatRadius.interpolation)))
endf += endfFormatsModule.endfNdDataList(
scatRadius.convertAxisToUnit(0, '10*fm'))
AP = 0
else:
AP = self.scatteringRadius.getValueAs('10*fm')
L_list = self.resonanceParameters.table.getColumn('L')
NLS = len(set(L_list))
LAD = getattr(self, 'computeAngularDistribution') or 0
NLSC = getattr(self, 'LvaluesNeededForConvergence') or 0
endf += [
endfFormatsModule.endfHeadLine(targetInfo['spin'], AP, LAD, 0, NLS,
NLSC)
]
table = [
self.resonanceParameters.table.getColumn('energy', units='eV'),
self.resonanceParameters.table.getColumn('J')
]
NE = len(table[0])
if isinstance(self, (resonancesModule.SLBW, resonancesModule.MLBW)):
attrList = ('totalWidth', 'neutronWidth', 'captureWidth',
'fissionWidthA')
elif isinstance(self, resonancesModule.RM):
attrList = ('neutronWidth', 'captureWidth', 'fissionWidthA',
'fissionWidthB')
for attr in attrList:
column = self.resonanceParameters.table.getColumn(attr, units='eV')
if not column: column = [0] * NE
table.append(column)
CS = self.resonanceParameters.table.getColumn('channelSpin')
if CS is not None: # ENDF hack: J<0 -> use lower available channel spin
targetSpin = targetInfo['spin']
CS = [2 * (cs - targetSpin) for cs in CS]
Js = [v[0] * v[1] for v in zip(table[1], CS)]
table[1] = Js
table = zip(*table)
for L in set(L_list):
APL = 0
if self.scatteringRadius.isLdependent(
) and L in self.scatteringRadius.form.lvals:
APL = self.scatteringRadius.getValueAs('10*fm', L=L)
resonances = [table[i] for i in range(NE) if L_list[i] == L]
NRS = len(resonances)
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['mass'], APL, L, 0,
6 * NRS, NRS))
for row in resonances:
endf.append(endfFormatsModule.endfDataLine(row))
return endf