def toENDF6(self, baseMT, endfMFList, flags, targetInfo):
MF, MT, LP = 12, baseMT + int(self.label), 0
nGammas, gammaData, levelEnergy_eV = len(
self.gammas), [], self.energy.getValueAs('eV')
for gamma in self.gammas:
gammaData.append(gamma.toENDF6List())
LGp = len(gammaData[0])
for gamma in gammaData:
gamma[0] = levelEnergy_eV - gamma[0]
endfMFList[MF][MT] = [
endfFormatsModule.endfHeadLine(targetInfo['ZA'], targetInfo['mass'], 2,
LGp - 1, MT - baseMT, 0),
endfFormatsModule.endfHeadLine(levelEnergy_eV, 0., LP, 0,
LGp * nGammas, nGammas)
]
gammaData.sort(reverse=True)
endfMFList[MF][MT] += endfFormatsModule.endfNdDataList(gammaData)
endfMFList[MF][MT].append(endfFormatsModule.endfSENDLineNumber())
# Currently, assume all distributions are isotropic
endfMFList[14][MT] = [
endfFormatsModule.endfHeadLine(targetInfo['ZA'], targetInfo['mass'], 1,
0, nGammas, 0)
]
endfMFList[14][MT].append(endfFormatsModule.endfSENDLineNumber())
def toENDF6(self, endfMFList, flags, targetInfo, verbosityIndent=''):
ZAM, AWT = targetInfo['ZA'], targetInfo['mass']
NIS, ABN = 1, 1.0
ZAI = ZAM # assuming only one isotope per file
# get target spin from the particle list:
target = targetInfo['reactionSuite'].getParticle(
targetInfo['reactionSuite'].target.name)
targetInfo['spin'] = target.getSpin().value
endf = [endfFormatsModule.endfHeadLine(ZAM, AWT, 0, 0, NIS, 0)]
resolvedCount, unresolvedCount = 0, 0
# resolved may have multiple energy regions:
if self.resolved is not None:
resolvedCount = max(1, len(self.resolved.regions))
if self.unresolved is not None: unresolvedCount = 1
# resonances may only contain a scattering radius:
if not (resolvedCount + unresolvedCount) and self.scatteringRadius:
scatRadius = self.scatteringRadius.form
lowerBound, upperBound = scatRadius.bounds
endf.append(endfFormatsModule.endfHeadLine(ZAM, ABN, 0, 0, 1, 0))
endf.append(
endfFormatsModule.endfHeadLine(lowerBound.getValueAs('eV'),
upperBound.getValueAs('eV'), 0, 0,
0, 0))
AP = scatRadius.value.getValueAs('10*fm')
endf.append(
endfFormatsModule.endfHeadLine(targetInfo['spin'], AP, 0, 0, 0, 0))
endf.append(endfFormatsModule.endfSENDLineNumber())
endfMFList[2][151] = endf
return
# For now I'm storing the LRF/LFW flags in xml, since they are tricky to compute
# LFW is a pain: only applies to unresolved, but must be written at the start of MF2
LRFurr, LFW = 0, 0
if unresolvedCount != 0:
LRF_LFW = self.unresolved.evaluated.ENDFconversionFlag
LRFurr, LFW = map(int, LRF_LFW.split('=')[-1].split(','))
NER = resolvedCount + unresolvedCount
endf.append(endfFormatsModule.endfHeadLine(ZAI, ABN, 0, LFW, NER, 0))
for idx in range(resolvedCount):
if resolvedCount == 1: region = self.resolved
else: region = self.resolved.regions[idx]
LRU = 1 #resolved
LRF = {
resonancesModule.SLBW.moniker: 1,
resonancesModule.MLBW.moniker: 2,
resonancesModule.RM.moniker: 3,
resonancesModule.RMatrix.moniker: 7
}[region.evaluated.moniker]
EL, EH = region.lowerBound.getValueAs(
'eV'), region.upperBound.getValueAs('eV')
if LRF == 7: NRO = 0
else: NRO = region.evaluated.scatteringRadius.isEnergyDependent()
NAPS = not (region.evaluated.calculateChannelRadius)
endf.append(endfFormatsModule.endfHeadLine(EL, EH, LRU, LRF, NRO,
NAPS))
endf += region.evaluated.toENDF6(flags, targetInfo, verbosityIndent)
if unresolvedCount != 0:
LRU = 2 #unresolved
region = self.unresolved
EL, EH = region.lowerBound.getValueAs(
'eV'), region.upperBound.getValueAs('eV')
NRO, NAPS = 0, 0
if region.evaluated.scatteringRadius.isEnergyDependent(): NRO = 1
endf.append(
endfFormatsModule.endfHeadLine(EL, EH, LRU, LRFurr, NRO, NAPS))
# pass LFW/LRF so we don't have to calculate twice:
targetInfo['unresolved_LFW'] = LFW
targetInfo['unresolved_LRF'] = LRFurr
targetInfo['regionEnergyBounds'] = (region.lowerBound,
region.upperBound)
endf += region.evaluated.toENDF6(flags, targetInfo, verbosityIndent)
endf.append(endfFormatsModule.endfSENDLineNumber())
endfMFList[2][151] = endf
def gammasToENDF6_MF12_13(MT, MF, endfMFList, flags, targetInfo, gammas):
"""
MF=12 stores the multiplicity for gamma products, can be converted directly to/from GND.
MF=13 stores 'gamma production cross section', equal to cross section * multiplicity.
ENDF-to-GND translator converts to multiplicity (dividing by reaction cross section).
When writing back to ENDF-6 MF=13, need to convert back using adjustMF13Multiplicity.
"""
doMF4AsMF6 = targetInfo['doMF4AsMF6']
targetInfo['doMF4AsMF6'] = False
ZA, mass, MFGammas, NI, continuum, NK, NKp = targetInfo['ZA'], targetInfo[
'mass'], [], 0, None, len(gammas), 0
total, piecewise, recomputeTotal = None, None, False
crossSection = None
if (MF == 13):
crossSection = targetInfo['crossSection']
crossSection = crossSection.toPointwise_withLinearXYs(accuracy=1e-3,
upperEps=1e-8)
if (NK > 1):
# If more than one gamma is present, both MF=12 and MF=13 start with the sum over all gammas.
# Search for the correct multiplicitySum in reactionSuite/sums section
total = [
tmp for tmp in targetInfo['reactionSuite'].sums.multiplicities
if tmp.ENDF_MT == MT
]
if len(total) > 1:
raise Exception(
"Cannot find unique gamma multiplicity sum for MT%d" % MT)
elif not total: # total multiplicity is missing from sums section, need to recompute from parts
recomputeTotal = True
else:
total = total[0].multiplicity.evaluated
for gammaIndex, gamma in enumerate(gammas):
distribution = gamma.distribution
component = distribution[targetInfo['style']]
if (isinstance(component, unspecifiedModule.form)): continue
NKp += 1
originationLevel = 0
if ('originationLevel' in gamma.attributes):
originationLevel = PQUModule.PQU(
gamma.getAttribute('originationLevel')).getValueAs('eV')
isPrimary, isDiscrete = False, False
if (isinstance(component, uncorrelatedModule.form)):
energySubform = component.energySubform.data
if (isinstance(energySubform, energyModule.primaryGamma)):
isPrimary = True
elif (isinstance(energySubform, energyModule.discreteGamma)):
isDiscrete = True
angularSubform = component.angularSubform.data
else:
raise 'hell - fix me'
LP, LF, levelEnergy = 0, 2, 0.
if (isPrimary):
gammaEnergy = PQUModule.PQU(
energySubform.value,
energySubform.axes[1].unit).getValueAs('eV')
LP = 2
elif (isDiscrete):
gammaEnergy = PQUModule.PQU(
energySubform.value,
energySubform.axes[1].unit).getValueAs('eV')
if (originationLevel != 0): LP = 1
else:
if (continuum is not None):
raise Exception(
'Multiple continuum gammas detected for MT=%s' % (MT))
continuum = gamma
energySubform = component.energySubform.data
gammaEnergy, LP, LF = 0, 0, 1
NC, MF15 = energySubform.toENDF6(flags, targetInfo)
endfMFList[15][MT] = [
endfFormatsModule.endfContLine(ZA, mass, 0, 0, NC, 0)
]
endfMFList[15][MT] += MF15
endfMFList[15][MT].append(endfFormatsModule.endfSENDLineNumber())
isNotIsotropic = 0
if (isinstance(angularSubform, angularModule.isotropic)):
MF14 = None
LI, LTT = 1, 0
elif (isinstance(angularSubform, angularModule.XYs2d)):
isNotIsotropic = 1
targetInfo['doProductionGamma'] = True
dummy, dummy, MF14 = angularSubform.toENDF6(flags, targetInfo)
del targetInfo['doProductionGamma']
del MF14[-1]
MF14[0] = endfFormatsModule.floatToFunky(
gammaEnergy) + endfFormatsModule.floatToFunky(
originationLevel) + MF14[0][22:]
LI, LTT = 0, 1
else:
raise 'hell - fix me'
multiplicity = gamma.multiplicity.evaluated
if recomputeTotal:
if (isinstance(multiplicity, multiplicityModule.regions1d)):
if (piecewise is not None):
if (len(piecewise) != len(multiplicity)):
raise Exception(
'MF=12/13 piecewise multiplicities must all have same number of regions'
)
for i1, region in enumerate(piecewise):
region.setData(
(region + multiplicity[i1]).copyDataToXYs())
else:
piecewise = multiplicity
total = piecewise[
0] # BRB, FIXME, this is a kludge until total is put into sums.
elif (total is None):
total = multiplicity
else:
total = total + multiplicity
if (MF == 12):
LO = 1
NR, NP, MF12or13Data = multiplicity.toENDF6List(targetInfo)
if (type(NR) == type([])):
for index, NRsub in enumerate(
endfFormatsModule.endfInterpolationList(NR)):
MF12or13Data.insert(index, NRsub)
NR = len(NR) / 2
MF12 = [
endfFormatsModule.endfContLine(gammaEnergy, originationLevel,
LP, LF, NR, NP)
] + MF12or13Data
MFGammas.append(
[isNotIsotropic, gammaEnergy, originationLevel, MF12, MF14])
elif (MF == 13):
LO = 0
interpolationInfo = []
xsec_mult = []
if (isinstance(multiplicity, multiplicityModule.XYs1d)):
adjustMF13Multiplicity(interpolationInfo, xsec_mult,
multiplicity, crossSection)
elif (isinstance(multiplicity, multiplicityModule.regions1d)):
for region in multiplicity:
adjustMF13Multiplicity(interpolationInfo, xsec_mult,
region, crossSection)
else:
raise Exception('Unsupport multiplicity "%s" for MF=13' %
multiplicity.moniker)
NR = len(interpolationInfo) / 2
NP = len(xsec_mult) / 2
MF13 = [
endfFormatsModule.endfContLine(gammaEnergy, originationLevel,
LP, LF, NR, NP)
]
MF13 += [
endfFormatsModule.endfInterpolationLine(interpolationInfo)
]
MF13 += endfFormatsModule.endfNdDataList(xsec_mult)
MFGammas.append(
[isNotIsotropic, gammaEnergy, originationLevel, MF13, MF14])
else:
pass
if (NKp == 0): return
endfMFList[MF][MT] = [
endfFormatsModule.endfContLine(ZA, mass, LO, 0, NK, 0)
]
if (
NK > 1
): # If more than one gamma is present, both MF=12 and MF=13 start with the sum over all gammas.
totalInterpolationInfo = []
xsec_mult = []
if (isinstance(total, multiplicityModule.XYs1d)):
adjustMF13Multiplicity(totalInterpolationInfo, xsec_mult, total,
crossSection)
elif (isinstance(total, multiplicityModule.regions1d)):
for region in total:
adjustMF13Multiplicity(totalInterpolationInfo, xsec_mult,
region, crossSection)
else:
raise Exception(
'Unsupported total multiplicity type "%s" for MF=13' %
total.moniker)
NR = len(totalInterpolationInfo) / 2
NP = len(xsec_mult) / 2
endfMFList[MF][MT].append(
endfFormatsModule.endfContLine(0, 0, 0, 0, NR, NP))
endfMFList[MF][MT] += [
endfFormatsModule.endfInterpolationLine(totalInterpolationInfo)
]
endfMFList[MF][MT] += endfFormatsModule.endfNdDataList(xsec_mult)
MFGammas12_13 = [[gammaEnergy, originationLevel, MF12_13]
for isNotIsotropic, gammaEnergy, originationLevel,
MF12_13, MF14 in MFGammas]
MFGammas12_13.sort(reverse=True)
for gammaEnergy, originationLevel, MF12_13 in MFGammas12_13:
endfMFList[MF][MT] += MF12_13 # Store MF 12 or 13 before sorting.
MFGammas.sort(reverse=True)
for isNotIsotropic, gammaEnergy, originationLevel, MF12_13, MF14 in MFGammas:
if (isNotIsotropic): break
NI += 1
if (LI == 1): NI = 0
endfMFList[MF][MT].append(endfFormatsModule.endfSENDLineNumber())
# if any gammas are anisotropic, MF14 data must be supplied for all gammas:
isotropic = [gamma for gamma in MFGammas if not gamma[0]]
anisotropic = [gamma for gamma in MFGammas if gamma[0]]
if anisotropic:
LI, LTT, NI = 0, 1, len(isotropic)
endfMFList[14][MT] = [
endfFormatsModule.endfContLine(ZA, mass, LI, LTT, NK, NI)
]
for gamma in isotropic:
endfMFList[14][MT].append(
endfFormatsModule.endfContLine(gamma[1], gamma[2], 0, 0, 0, 0))
for gamma in anisotropic:
endfMFList[14][MT] += gamma[-1]
endfMFList[14][MT].append(endfFormatsModule.endfSENDLineNumber())
else:
endfMFList[14][MT] = [
endfFormatsModule.endfContLine(ZA, mass, LI, LTT, NK, NI),
endfFormatsModule.endfSENDLineNumber()
]
targetInfo['doMF4AsMF6'] = doMF4AsMF6
def toENDF6( self, style, flags, verbosityIndent = '', covarianceSuite = None ) :
evaluatedStyle = self.styles.getEvaluatedStyle( )
if( evaluatedStyle is None ) : raise ValueError( 'no evaluation style found' )
if( flags['verbosity'] >= 10 ) : print '%s%s' % ( verbosityIndent, self.inputParticlesToReactionString( suffix = " -->" ) )
verbosityIndent2 = verbosityIndent + ' ' * ( len( self.inputParticlesToReactionString( suffix = " -->" ) ) + 1 )
projectile, target = self.projectile, self.target
projectileZA = projectile.getZ_A_SuffixAndZA( )[-1]
IPART = projectileZA
if( projectile.name == 'e-' ) : IPART = 11
targetZA, MAT = endf_endl.ZAAndMATFromParticleName( target.name )
targetZ, targetA = divmod( targetZA, 1000 )
targetInfo = processingInfoModule.tempInfo( )
targetInfo['style'] = style
targetInfo['reactionSuite'] = self
targetInfo['ZA'] = targetZA
if( self.particles.hasID( 'n' ) ) : # Need neutron mass in eV/c**2, but it may not be in the particle list.
targetInfo['neutronMass'] = self.getParticle( 'n' ).getMass( 'eV/c**2' )
else :
neutronAmu = masses.getMassFromZA( 1 )
targetInfo['neutronMass'] = PQU.PQU( neutronAmu, 'amu' ).getValueAs('eV/c**2')
if( isinstance( target, fudge.gnd.xParticle.element ) ) :
targetInfo['mass'] = elementalMass[targetZA]
else :
targetInfo['mass'] = target.getMass( 'eV/c**2' ) / targetInfo['neutronMass']
try :
targetInfo['LIS'] = target['levelIndex']
except :
targetInfo['LIS'] = 0
targetInfo['metastables'] = []
targetInfo['LISO'] = 0
for key, alias in self.aliases.items( ) :
if( alias.hasAttribute( 'nuclearMetaStable' ) ) :
targetInfo['metastables'].append( alias.getValue() )
if( alias.getValue() == target.name ) :
targetInfo['LISO'] = int( alias.getAttribute( 'nuclearMetaStable' ) )
MAT += targetInfo['LISO']
if( self.MAT is not None ) : MAT = self.MAT
ITYPE = 0 # Other ITYPE sublibraries not yet supported. BRB is this still true
for reaction in self.reactions :
if( 500 <= reaction.ENDF_MT < 573 ) : ITYPE = 3
targetInfo['crossSectionMF'] = { 0 : 3, 3 : 23 }[ITYPE]
targetInfo['delayedRates'] = []
targetInfo['totalDelayedNubar'] = None
targetInfo['MTs'], targetInfo['MF8'], targetInfo['LRs'] = {}, {}, {}
endfMFList = { 1 : { 451 : [] }, 2 : {}, 3 : {}, 4 : {}, 5 : {}, 6 : {}, 8 : {}, 9 : {}, 10 : {}, 12 : {}, 13 : {},
14 : {}, 15 : {}, 23 : {}, 26 : {}, 27 : {}, 31 : {}, 32 : {}, 33 : {}, 34 : {}, 35 : {}, 40 : {} }
if( self.resonances is not None ) : # Add resonances, independent of reaction channels
self.resonances.toENDF6( endfMFList, flags, targetInfo, verbosityIndent=verbosityIndent2 )
targetInfo['production_gammas'] = {}
for reaction in self :
reaction.toENDF6( endfMFList, flags, targetInfo, verbosityIndent = verbosityIndent2 )
gndToENDF6Module.upDateENDFMF8Data( endfMFList, targetInfo )
for MT, production_gammas in targetInfo['production_gammas'].items( ) :
MF, production_gammas = production_gammas[0], production_gammas[1:]
for productionReaction in production_gammas :
gammas = [ gamma for gamma in productionReaction.outputChannel ]
targetInfo['crossSection'] = productionReaction.crossSection[targetInfo['style']]
gndToENDF6Module.gammasToENDF6_MF12_13( MT, MF, endfMFList, flags, targetInfo, gammas )
for particle in self.particles : # gamma decay data.
if( isinstance( particle, fudge.gnd.xParticle.isotope ) ) :
for level in particle :
if( level.gammas ) : # non-empty gamma information
for baseMT in [ 50, 600, 650, 700, 750, 800 ] :
residualZA = endf_endl.ENDF_MTZAEquation( projectileZA, targetZA, baseMT )[0][-1]
if( nuclear.nucleusNameFromZA( residualZA ) == particle.name ) : break
level.toENDF6( baseMT, endfMFList, flags, targetInfo )
MFs = sorted( endfMFList.keys( ) )
endfList = []
totalNubar = None
totalDelayedNubar = targetInfo['totalDelayedNubar']
if( 455 in endfMFList[5] ) :
MF5MT455s = endfMFList[5][455]
endfMFList[1][455] = [ endfFormatsModule.endfHeadLine( targetZA, targetInfo['mass'], 0, 2, 0, 0 ) ] # Currently, only LDG = 0, LNU = 2 is supported.
endfMFList[1][455] += [ endfFormatsModule.endfHeadLine( 0, 0, 0, 0, len( targetInfo['delayedRates'] ), 0 ) ]
endfMFList[1][455] += endfFormatsModule.endfDataList( targetInfo['delayedRates'] )
multiplicityModule.fissionNeutronsToENDF6( 455, totalDelayedNubar, endfMFList, flags, targetInfo )
MF5MT455List = [ endfFormatsModule.endfHeadLine( targetZA, targetInfo['mass'], 0, 0, len( MF5MT455s ), 0 ) ]
for MF5MT455 in MF5MT455s : MF5MT455List += MF5MT455
if( len( MF5MT455s ) == 0 ) :
del endfMFList[5][455]
else :
endfMFList[5][455] = MF5MT455List + [ endfFormatsModule.endfSENDLineNumber( ) ]
if( 'promptNubar' in targetInfo.dict ) :
promptNubar = targetInfo['promptNubar']
multiplicityModule.fissionNeutronsToENDF6( 456, promptNubar, endfMFList, flags, targetInfo )
totalNubar = promptNubar
try :
if( not( totalDelayedNubar is None ) ) : totalNubar = totalNubar + totalDelayedNubar
except : # The following is a kludge for some "bad" data.
if( ( totalNubar.domainMax( unitTo = 'MeV' ) == 30. ) and
( totalDelayedNubar.domainMax( unitTo = 'MeV' ) == 20. ) ) :
totalDelayedNubar[-1] = [ totalNubar.domainMax( ), totalDelayedNubar.getValue( totalDelayedNubar.domainMax( ) ) ]
totalNubar = totalNubar + totalDelayedNubar
elif( 'totalNubar' in targetInfo.dict ) :
totalNubar = targetInfo['totalNubar']
if( totalNubar is not None ) :
multiplicityModule.fissionNeutronsToENDF6( 452, totalNubar, endfMFList, flags, targetInfo )
if( covarianceSuite ) : covarianceSuite.toENDF6( endfMFList, flags, targetInfo )
endfDoc = self.documentation.get( 'endfDoc' )
if( endfDoc is None ) :
docHeader2 = [ ' %2d-%-2s-%3d LLNL EVAL-OCT03 Unknown' % ( targetZ, fudge.particles.nuclear.elementSymbolFromZ( targetZ ), targetA ),
' DIST-DEC99 19990101 ',
'----ENDL MATERIAL %4d' % MAT,
'-----INCIDENT %s DATA' %
{ 1 : 'NEUTRON', 1001 : 'PROTON', 1002 : 'DEUTERON', 1003 : 'TRITON', 2003 : 'HELION', 2004 : 'ALPHA' }[projectileZA],
'------ENDF-6 FORMAT' ]
endfDoc = [ 'LLNL ENDL file translated to ENDF6 by FUDGE.', '' ' ************************ C O N T E N T S ***********************' ]
else :
docHeader2 = []
endfDoc = endfDoc.getLines( )
# update the documentation, including metadata on first 4 lines:
try :
self.getReaction( 'fission' )
LFI = True
except KeyError :
LFI = False
LRP = -1
if( self.resonances is not None ) :
if( self.resonances.scatteringRadius ) :
LRP = 0
elif( self.resonances.reconstructCrossSection ) :
LRP = 1
elif( self.resonances.unresolved and not( self.resonances.resolved )
and self.resonances.unresolved.tabulatedWidths.forSelfShieldingOnly ) :
LRP = 1
else :
LRP = 2
EMAX = max( [ reaction.crossSection.domainMax( unitTo = 'eV' ) for reaction in self.reactions ] )
temperature = self.styles[style].temperature.getValueAs( 'K' )
library = evaluatedStyle.library
version = evaluatedStyle.version
if( library == 'ENDL' ) : # Additional ENDF meta-data. If the library is unknown, use NLIB = -1
NVER, LREL, NMOD = 1, 1, 1
NLIB = -1
else :
NVER, LREL, NMOD = map( int, version.split( '.' ) ) # Version stored as '7.2.1'
NLIB = { "ENDF/B" : 0, "ENDF/A" : 1, "JEFF" : 2, "EFF" : 3, "ENDF/B (HE)" : 4,
"CENDL" : 5, "JENDL" : 6, "SG-23" : 21, "INDL/V" : 31, "INDL/A" : 32,
"FENDL" : 33, "IRDF" : 34, "BROND (IAEA version)" : 35, "INGDB-90" : 36, "FENDL/A" : 37,
"BROND" : 41 }.get( library, -1 )
NFOR = 6 # ENDF-6 format
NSUB = 10 * IPART + ITYPE
LDRV = 0
STA = 0
if( isinstance( self.target, fudge.gnd.xParticle.nuclearLevel ) or self.target.attributes.get( 'unstable' ) ) : STA = 1
if( targetInfo['LISO'] ) : STA = 1
levelIndex, level_eV = 0, 0.
if( hasattr( self.target, 'getLevelIndex' ) ) : levelIndex, level_eV = self.target.getLevelIndex( ), self.target.getLevelAsFloat( 'eV' )
docHeader = [ endfFormatsModule.endfHeadLine( targetZA, targetInfo['mass'], LRP, LFI, NLIB, NMOD ),
endfFormatsModule.endfHeadLine( level_eV, STA, levelIndex, targetInfo['LISO'], 0, NFOR ),
endfFormatsModule.endfHeadLine( self.projectile.getMass( 'eV/c**2' ) / targetInfo['neutronMass'], EMAX, LREL, 0, NSUB, NVER ),
endfFormatsModule.endfHeadLine( temperature, 0, LDRV, 0, len( endfDoc ), -1 ) ]
new_doc = fudge.gnd.documentation.documentation( 'endf', '\n'.join( docHeader + docHeader2 + endfDoc ) )
endfMFList[1][451] += endfFormatsModule.toEndfStringList( new_doc )
return( endfFormatsModule.endfMFListToFinalFile( endfMFList, MAT, lineNumbers = True ) )
def upDateENDF_MT_MF8Data(MT, endfMFList, targetInfo):
reactionSuite = targetInfo['reactionSuite']
MF8Channels = targetInfo['MF8'][MT]
ZA, mass = targetInfo['ZA'], targetInfo['mass']
LIS, LISO, NO, NS = targetInfo['LIS'], targetInfo['LISO'], 1, len(
MF8Channels)
firstReaction = MF8Channels[0]
residual = firstReaction.outputChannel[0]
crossSection_ = firstReaction.crossSection[
targetInfo['style']] # LMF determines which MF section to write to.
if (isinstance(crossSection_, crossSectionModule.reference)):
multiplicity = residual.multiplicity[targetInfo['style']]
if (isinstance(multiplicity, multiplicityModule.constant1d)):
LMF = 3
elif (isinstance(multiplicity, multiplicityModule.reference)):
LMF = 6
else:
LMF = 9
else:
LMF = 10
level = 0
if (hasattr(residual, 'getLevelAsFloat')):
level = residual.getLevelAsFloat('eV')
endfMFList[8][MT] = [
endfFormatsModule.endfHeadLine(ZA, mass, LIS, LISO, NS, NO)
]
if (LMF not in [3, 6]):
endfMFList[LMF][MT] = [
endfFormatsModule.endfHeadLine(ZA, mass, LIS, 0, NS, 0)
]
for reaction in MF8Channels:
outputChannel = reaction.outputChannel
if (len(outputChannel) != 1):
raise Exception(
'Currently, production channel can only have one product; not %d'
% len(outputChannel))
product = outputChannel[0]
particle = reactionSuite.PoPs[product.id]
ZAP = miscPoPsModule.ZA(particle)
QI = outputChannel.getConstantQAs('eV', final=True)
LFS2, level2 = 0, 0
if (isinstance(particle, nuclearLevelModule.particle)):
LFS2 = particle.intIndex
level2 = particle.energy[0].float('eV')
QM = QI + level2
endfMFList[8][MT].append(
endfFormatsModule.endfHeadLine(ZAP, level2, LMF, LFS2, 0, 0))
if (
LMF == 9
): # Currenty, multiplicity.toENDF6List only has one interpolation and its linear.
multiplicity = product.multiplicity[targetInfo['style']]
interpolationFlatData, nPoints, multiplicityList = multiplicity.toENDF6List(
targetInfo)
endfMFList[LMF][MT].append(
endfFormatsModule.endfHeadLine(QM, QI, ZAP, LFS2,
len(interpolationFlatData) / 2,
nPoints))
endfMFList[LMF][MT] += endfFormatsModule.endfInterpolationList(
interpolationFlatData)
endfMFList[LMF][MT] += multiplicityList
elif (LMF == 10):
interpolationFlatData, flatData = reaction.crossSection[
targetInfo['style']].toENDF6Data(MT, endfMFList, targetInfo,
level2)
endfMFList[LMF][MT].append(
endfFormatsModule.endfHeadLine(QM, QI, ZAP, LFS2,
len(interpolationFlatData) / 2,
len(flatData) / 2))
endfMFList[LMF][MT] += endfFormatsModule.endfInterpolationList(
interpolationFlatData)
endfMFList[LMF][MT] += endfFormatsModule.endfDataList(flatData)
endfMFList[8][MT].append(endfFormatsModule.endfSENDLineNumber())
if (LMF not in [3, 6]):
endfMFList[LMF][MT].append(endfFormatsModule.endfSENDLineNumber())