def check( self, info ) :
"""
Check for incomplete angular distributions + any negative probabilities.
Ignore normalization for this double-differential distribution.
"""
from fudge.gnd import warning
from pqu import PQU
warnings = []
for index, energy_in in enumerate(self):
integral = energy_in.integrate()
if abs(integral - 1.0) > info['normTolerance']:
warnings.append( warning.unnormalizedDistribution( PQU.PQU(energy_in.value, self.axes[0].unit),
index, integral, self.toXLink() ) )
if( energy_in.domainMin != -1 ) or ( energy_in.domainMax != 1 ) :
warnings.append( warning.incompleteDistribution( PQU.PQU(energy_in.value, self.axis[0].unit),
energy_in.domainMin, energy_in.domainMax, energy_in ) )
for mu in energy_in:
if( mu.domainMin < 0 ) :
warnings.append( warning.valueOutOfRange("Negative outgoing energy for energy_in=%s!"
% PQU.PQU(energy_in.value, self.axes[0].unit), mu.domainMin, 0, 'inf', self.toXLink() ) )
if( mu.rangeMin < 0 ) :
warnings.append( warning.negativeProbability( PQU.PQU(energy_in.value, self.axes[-1].unit),
mu=mu.value, obj=mu ) )
return warnings
def test_getMatchingComponent_1(self):
'''Fails because there is no component of section 1 with such bounds'''
self.assertRaises(ValueError,
FeCovariance[1]['eval'].getMatchingComponent,
rowBounds=(PQU.PQU("1.e-5 eV"), PQU.PQU("2.e7 eV")),
columnBounds=(PQU.PQU("1.e-5 eV"),
PQU.PQU("2.e7 eV")))
def toENDL(incoherentElastic, energyMin_MeV, energyMax_MeV, temperature_MeV):
sigma_b = incoherentElastic.characteristicCrossSection.getValueAs('b')
temperature = PQUModule.PQU(temperature_MeV, 'MeV/k').getValueAs(
incoherentElastic.DebyeWaller.axes[1].unit)
debyeWallerPrime = incoherentElastic.DebyeWaller.evaluate(temperature)
debyeWallerPrime = PQUModule.PQU(
debyeWallerPrime,
incoherentElastic.DebyeWaller.axes[0].unit).getValueAs('1/MeV')
parameters = {'debyeWallerPrime': debyeWallerPrime, 'sigma_b': sigma_b}
crossSection = [[energy, crossSectionAtEnergy(energy, parameters)]
for energy in [energyMin_MeV, energyMax_MeV]]
crossSection = fudgemath.thickenXYList(crossSection,
evaluator(crossSectionAtEnergy,
parameters),
biSectionMax=12)
PmuGivenE = []
for energy, sigma in crossSection:
parameters['energy'] = energy
PmuForEachE = [[mu, incoherentElasticPmuGivenE(mu, parameters)]
for mu in [-1., 1.]]
PmuForEachE = fudgemath.thickenXYList(PmuForEachE,
evaluator(
incoherentElasticPmuGivenE,
parameters),
biSectionMax=12)
PmuGivenE.append([energy, PmuForEachE])
return (crossSection, PmuGivenE, None)
def check(self, info):
from fudge.gnd import warning
warnings = []
if (not (self.aSubform.isEmptyASubform())):
raise NotImplementedError(
"Checking for Kalbach-Mann data with 'a' coefficients")
for index, F in enumerate(
self.fSubform.data
): # F is like P(E' | E), must be normalized for each incident energy
integral = F.integrate()
if abs(integral - 1.0) > info['normTolerance']:
warnings.append(
warning.unnormalizedKMDistribution(
PQUModule.PQU(F.value, F.axes[-1].unit), index,
integral, F))
if F.rangeMin < 0:
warnings.append(
warning.negativeProbability(PQUModule.PQU(
F.value, F.axes[-1].unit),
obj=F))
for R in self.rSubform.data: # R = pre-compound fraction, must be between 0 and 1
if R.rangeMin < 0 or R.rangeMax > 1:
badR = R.rangeMin if (
0.5 - R.rangeMin > R.rangeMax - 0.5) else R.rangeMax
warnings.append(
warning.valueOutOfRange(
"Invalid 'r' in KalbachMann distribution at incident energy %s"
% PQUModule.PQU(R.value, R.axes[-1].unit), badR, 0, 1,
R))
return warnings
def toENDF6( self, flags, targetInfo ) :
MT = 5
EInInterpolation = gndToENDF6Module.gndToENDF2PlusDInterpolationFlag( self.interpolation, self.interpolationQualifier )
EpInterpolation0 = gndToENDF6Module.gndToENDF2PlusDInterpolationFlag( self[0].interpolation, self[0].interpolationQualifier )
if( EpInterpolation0 == 1 ) : # flat interpolation
LEP = 1
elif( EpInterpolation0 == 2 ) : # lin-lin interpolation
LEP = 2
else :
raise 'hell - fix me'
ENDFDataList = [ endfFormatsModule.endfContLine( 0, 0, 1, LEP, 1, len( self ) ) ]
ENDFDataList += endfFormatsModule.endfInterpolationList( [ len( self ), EInInterpolation ] )
energyInFactor = PQUModule.PQU( 1, self.axes[3].unit ).getValueAs( 'eV' )
energyPFactor = PQUModule.PQU( 1, self.axes[2].unit ).getValueAs( 'eV' )
for energyIn in self :
if( not( isinstance( energyIn, multiD_XYsModule.XYs2d ) ) ) : raise 'hell - fix me'
EpInterpolation = gndToENDF6Module.gndToENDF2PlusDInterpolationFlag( energyIn.interpolation, energyIn.interpolationQualifier )
if( EpInterpolation != EpInterpolation0 ) : raise 'hell - fix me'
NA, data = 0, []
for energy_p in energyIn :
if( not( isinstance( energy_p, series1dModule.LegendreSeries ) ) ) : raise 'hell - fix me'
NA = max( len( energy_p ) , NA )
coefficients = [ coefficient / energyPFactor for coefficient in energy_p ]
data += [ energy_p.value * energyPFactor ] + coefficients
ENDFDataList.append( endfFormatsModule.endfContLine( 0, energyIn.value * energyInFactor, 0, NA - 1, len( data ), len( data ) / ( NA + 1 ) ) )
ENDFDataList += endfFormatsModule.endfDataList( data )
LAW = 1
return( LAW, ENDFDataList )
def check(self, info):
from fudge.gnd import warning
warnings = []
for idx, function in enumerate(self):
xys = function.toPointwise_withLinearXYs(
accuracy=info['normTolerance'], lowerEps=1e-6)
if isinstance(function, Legendre):
integral = function.coefficients[0]
elif isinstance(function, XYs1d):
integral = xys.integrate(-1, 1)
else:
raise NotImplementedError(
"checking function of type %s" %
type(function)) # FIXME support xs_pdf_cdf1d
if abs(integral - 1.0) > info['normTolerance']:
warnings.append(
warning.unnormalizedDistribution(
PQUModule.PQU(function.value, self.axes[-1].unit), idx,
integral, function))
if (xys.rangeMin < 0.0):
warnings.append(
warning.negativeProbability(PQUModule.PQU(
function.value, self.axes[-1].unit),
value=xys.rangeMin,
obj=function))
return warnings
def toENDF6(self, flags, targetInfo, weight=None):
U, EFL, EFH = 0, 0, 0
if (self.LF == 12):
EFL, EFH = self.EFL.getValueAs('eV'), self.EFH.getValueAs('eV')
else:
U = self.U.getValueAs('eV')
parameter1 = self.parameter1.data
energyFactor = float(
PQUModule.PQU('1 eV') / PQUModule.PQU(1, parameter1.axes[1].unit))
if (weight is None):
weight = [[energyFactor * parameter1[0][0], 1.0],
[energyFactor * parameter1[-1][0], 1.0]]
interpolation = 2
elif (hasattr(weight, 'axes')):
interpolation = gndToENDF6Module.gndToENDFInterpolationFlag(
weight.interpolation)
else:
interpolation = 2
ENDFDataList = [ endfFormatsModule.endfContLine( U, 0, 0, self.LF, 1, len( weight ) ) ] + \
endfFormatsModule.endfInterpolationList( [ len( weight ), interpolation ] ) + endfFormatsModule.endfNdDataList( weight )
ENDFDataList += endfFormatsModule.toTAB1(parameter1,
'eV',
'eV',
C1=EFL,
C2=EFH)
if (self.parameter2 is not None):
parameter2 = self.parameter2.data
yUnit = ''
if (self.LF in [5, 11]): yUnit = '1/eV'
ENDFDataList += endfFormatsModule.toTAB1(parameter2, 'eV', yUnit)
return (1, ENDFDataList)
def computeScatteringRadius( rs, useCovariance=True, covariance=None, verbose=False ):
"""
Compute R', the scattering radius
We take the E=0 point (or at least the lowest available energy point in the elastic cross section).
with this,
..math::
\sigma_{el}=4\pi(R')^2
:param elxs: the elastic scattering cross section
:param useCovariance:
:param covariance:
:return:
"""
# get RRR parameter averages
if (hasattr(rs.resonances,'resolved') and rs.resonances.resolved is not None):
import fudge.processing.resonances.reconstructResonances as RRReconstruct
resCls = RRReconstruct.getResonanceReconstructionClass(rs.resonances.resolved.evaluated.moniker)
rrr = resCls( rs, None, enableAngDists=False, verbose=verbose )
rrr.setResonanceParametersByChannel()
R=rrr.getScatteringLength()
return PQU.PQU(10.*R,'fm')
elif (hasattr(rs.resonances,'scatteringRadius') and rs.resonances.scatteringRadius is not None):
return PQU.PQU(rs.resonances.scatteringRadius.getValueAs( 'fm', energy_grid=[1e-5], L=0 ),'fm')
else:
return PQU.PQU(0.0,'fm')
def toENDF6( self, MT, endfMFList, flags, targetInfo ) :
angularForm = self.angularForm
angularEnergyForm = self.angularEnergyForm
energy_inInterpolation, energy_inFunctionInterpolation, energy_inInterpolationQualifier = angularEnergyForm.axes[0].interpolation.getInterpolationTokens( )
muInterpolation, muFunctionInterpolation, muQualifier = angularEnergyForm.axes[1].interpolation.getInterpolationTokens( )
energy_outInterpolation, probabilityInterpolation, energy_outQualifier = angularEnergyForm.axes[2].interpolation.getInterpolationTokens( )
frame = angularEnergyForm.getProductFrame( )
axes = pointwise.defaultAxes( energyInterpolation = energy_inInterpolation, energyFunctionInterpolation = energy_inFunctionInterpolation,
energyInterpolationQualifier = energy_inInterpolationQualifier, muInterpolation = muInterpolation,
energy_outInterpolation = energy_outInterpolation, probabilityInterpolation = probabilityInterpolation )
E_inRatio = PQUModule.PQU( 1, angularEnergyForm.axes[0].getUnit( ) ).getValueAs( 'eV' )
E_outRatio = PQUModule.PQU( 1, angularEnergyForm.axes[2].getUnit( ) ).getValueAs( 'eV' )
LAW7 = pointwise( axes, self.getProductFrame( ) )
if( len( angularForm ) != len( angularEnergyForm ) ) :
raise Exception( "len( angularForm ) = %s != len( angularEnergyForm ) = %s" % ( len( angularForm ), len( angularEnergyForm ) ) )
for indexE, EMuP in enumerate( angularForm ) :
EMuEpP = angularEnergyForm[indexE]
if( EMuP.value != EMuEpP.value ) : raise Exception( "At indexE = %d, EMuP.value %s != EMuEpP.value = %s" % ( indexE, EMuP.value, EMuEpP.value ) )
if( len( EMuP ) != len( EMuEpP ) ) :
raise Exception( "At indexE = %d (E_in = %s), len( EMuP ) %s != len( EMuEpP ) = %s" % ( indexE, EMuP.value, len( EMuP ), len( EMuEpP ) ) )
w_xys = W_XYs.W_XYs( axesW_XY, index = indexE, value = EMuP.value )
for indexMu, muP in enumerate( EMuP ) :
muEpP = EMuEpP[indexMu]
if( muP[0] != muEpP.value ) : raise Exception( "At indexE = %d, mu = %s != muEpP.value = %s" % ( indexE, muP[0], muEpP.value ) )
xys = [ [ E_outRatio * Ep, muP[1] * P / E_outRatio ] for Ep, P in muEpP ]
xys = XYs.XYs( axesXY, xys, accuracy = muEpP.getAccuracy( ), value = muP[0], index = indexMu, parent = w_xys )
w_xys.append( XYs.XYs( axesXY, muEpP * muP[1], accuracy = muEpP.getAccuracy( ), value = muP[0], index = indexMu, parent = w_xys ) )
LAW7.append( w_xys )
LAW, frame, MF6 = LAW7.toENDF6( flags, targetInfo )
gndToENDF6Module.toENDF6_MF6( MT, endfMFList, flags, targetInfo, LAW, frame, MF6 )
def heat(self,
style,
EMin,
lowerlimit=None,
upperlimit=None,
interpolationAccuracy=0.002,
heatAllPoints=False,
doNotThin=True,
heatBelowThreshold=True,
heatAllEDomain=True,
setThresholdToZero=False,
addToSuite=False):
"""
Returns the result of self.toPointwise_withLinearXYs( ).heat( ... ). See method XYs1d.heat for more information.
If setThresholdToZero is True and self's cross section at the first point is 0., then the heated cross section's
first value will also be 0.
"""
styles = self.findAttributeInAncestry('styles')
currentstyle = styles[style.derivedFrom]
if (not (isinstance(currentstyle,
(stylesModule.evaluated, stylesModule.heated)))):
TypeError(
'Form to heat is not heatable form: its style moniker is "%s"'
% style.label)
currentTemperature = PQUModule.PQU(
currentstyle.temperature.getValueAs('K'),
'K') * PQUModule.PQU('1 k')
currentTemperature = currentTemperature.getValueAs(self.domainUnit)
newTemperature = PQUModule.PQU(style.temperature.getValueAs('K'),
'K') * PQUModule.PQU('1 k')
newTemperature = newTemperature.getValueAs(self.domainUnit)
reactionSuite = self.getRootAncestor()
projectile = reactionSuite.PoPs[reactionSuite.projectile]
projectileMass = projectile.getMass('amu')
if (projectileMass == 0):
raise ValueError('Heating with gamma as projectile not supported.')
target = reactionSuite.PoPs[reactionSuite.target]
massRatio = target.getMass('amu') / projectileMass
linear = self.toPointwise_withLinearXYs(accuracy=1e-5, upperEps=1e-8)
heated = linear.heat(currentTemperature,
newTemperature,
massRatio,
EMin,
lowerlimit,
upperlimit,
interpolationAccuracy,
heatAllPoints,
doNotThin,
heatBelowThreshold,
heatAllEDomain,
setThresholdToZero=setThresholdToZero)
heated.label = style.label
if (addToSuite): self.add(heated)
return (heated)
def test_RI_vs_INTER(self):
for r in self.eval['reactionSuite']:
if r.ENDF_MT==1:
self.assertIsClose(computeRI(r.crossSection,domainMax=PQU.PQU(1.00000E+05,'eV'),useCovariance=False), PQU.PQU(2.39596E+02,'b'), rel_tol=1e-5)
if r.ENDF_MT==2:
self.assertIsClose(computeRI(r.crossSection,domainMax=PQU.PQU(1.00000E+05,'eV'),useCovariance=False), PQU.PQU(2.39452E+02,'b'), rel_tol=1e-6)
if r.ENDF_MT==102:
self.assertIsClose(computeRI(r.crossSection,domainMax=PQU.PQU(1.00000E+05,'eV'),useCovariance=False), PQU.PQU(1.48914E-01,'b'), abs_tol=5e-6)
def getConstantAs( self, unit ) : # FIXME: Remove?
for form in self :
if( isinstance( form, constant1d ) ) :
return( PQUModule.PQU( form.constant, form.axes[0].unit ).getValueAs( unit ) )
elif( isinstance( form, fissionEnergyReleasedModule.fissionEnergyReleased ) ) :
return( PQUModule.PQU( form.nonNeutrinoEnergy.data.evaluate( 0 ) ) )
raise ValueError( 'Q-value is not a constant' )
def gammasToENDF6_MF6_oneGamma(MT, endfMFList, flags, targetInfo, gamma, LANG,
LEP, frame):
component = gamma.distribution[targetInfo['style']]
isPrimary, isDiscrete, energySubform, angularSubform = gammaType(component)
if (isPrimary or isDiscrete): return (False)
targetInfo['multiplicity'] = gamma.multiplicity[targetInfo['style']]
if (isinstance(component, uncorrelatedModule.form)):
angularSubform = component.angularSubform.data
energySubform = component.energySubform.data
if (not (isinstance(angularSubform, angularModule.isotropic))):
raise Exception('Unsupport angular form = "%s"' %
angularSubform.moniker)
if (not (isinstance(energySubform, energyModule.regions2d))):
energySubform = [energySubform]
interpolationEIn = gndToENDF2PlusDInterpolationFlag(
energySubform[0].interpolation,
energySubform[0].interpolationQualifier)
EInFactor = PQUModule.PQU(
1, energySubform[0].axes[2].unit).getValueAs('eV')
EOutFactor = PQUModule.PQU(
1, energySubform[0].axes[1].unit).getValueAs('eV')
NE, NR = 0, 1
ENDFDataList = []
for i1, region in enumerate(energySubform):
interpolationEIn = gndToENDF2PlusDInterpolationFlag(
region.interpolation, region.interpolationQualifier)
for energyInData in region:
NE += 1
EIn = energyInData.value
data = []
if (not (isinstance(energyInData, energyModule.regions1d))):
energyInData = [energyInData]
for region2 in energyInData:
for Ep, probability in region2:
data.append(Ep * EOutFactor)
data.append(probability / EOutFactor)
ENDFDataList += [
endfFormatsModule.endfContLine(0, EIn, 0, 0, len(data),
len(data) / 2)
]
ENDFDataList += endfFormatsModule.endfDataList(data)
else:
raise Exception('Unsupport continuum gamma distribution = "%s"' %
component.moniker)
interpolations = [NE, interpolationEIn]
ENDFDataList.insert(
0, endfFormatsModule.endfContLine(0, 0, LANG, LEP, NR, NE))
ENDFDataList.insert(
1, endfFormatsModule.endfInterpolationLine(interpolations))
toENDF6_MF6(MT, endfMFList, flags, targetInfo, 1, frame, ENDFDataList)
return (True)
def test_check(self):
from pqu import PQU
info = {
'Q': 1.0,
'kinematicFactor': 1.0,
'dThreshold': PQU.PQU('1e-4 b'),
'crossSectionEnergyMax': PQU.PQU('20.0 MeV'),
'CoulombChannel': False
}
self.assertEqual(self.xs_const.check(info), [])
def otherToSelfsUnits( self, other, checkXOnly = False ) :
if( not( isinstance( other, XYs1d ) ) ) : raise TypeError( 'other instance not XYs1d instance' )
if( ( self.axes is None ) and ( other.axes is None ) ) : return( other )
yScale = 1
xUnitSelf = PQU._getPhysicalUnit( self.axes[xAxisIndex].unit )
xScale = xUnitSelf.conversionFactorTo( other.axes[xAxisIndex].unit )
if( not( checkXOnly ) ) :
yUnitSelf = PQU._getPhysicalUnit( self.axes[yAxisIndex].unit )
yScale = yUnitSelf.conversionFactorTo( other.axes[yAxisIndex].unit )
if( ( xScale != 1 ) or ( yScale != 1 ) ) : other = other.scaleOffsetXAndY( xScale = xScale, yScale = yScale )
return( other )
def test_MACS(self):
"""
These test values come from B. Pritychenko, S.F. Mughabghab arXiv:1208.2879v3.
"""
for r in self.eval['reactionSuite']:
if r.ENDF_MT==102:
self.assertIsClose(computeMACS(r.crossSection, PQU.PQU(30.,'keV'),useCovariance=False), PQU.PQU(1.525E-4,'b'), abs_tol=1e-7)
self.assertIsClose(computeMACS(r.crossSection, PQU.PQU(1420.,'keV'),useCovariance=False), PQU.PQU(3.892E-5,'b'), abs_tol=2e-8)
# Turn on covariance, what happens then?
self.assertIsClose(computeMACS(r.crossSection, PQU.PQU(30.,'keV'),useCovariance=True), PQU.PQU("1.524e-4 +/- 5.6e-6 b"), abs_tol=1e-7)
break
def test_shrinkToBounds(self):
self.maxDiff = None
self.assertXMLListsEqual(
FeCovariance[0]['eval'].shrinkToBounds(
(PQU.PQU("862270 eV"), PQU.PQU("1.5e7 eV")), ).toXMLList(),
[
'<mixed>', ' <covarianceMatrix index="1" type="relative">',
' <axes>',
' <axis index="0" label="row_energy_bounds" unit="eV" interpolation="lin,flat" length="6"> 862270 1e6 2e6 5e6 1e7 1.5e7</axis>',
' <axis index="1" label="column_energy_bounds" unit="eV" interpolation="lin,flat" mirror_row_energy_bounds="true"/>',
' <axis index="2" label="matrix_elements" unit=""/></axes>',
' <matrix rows="6" columns="6" form="diagonal" precision="6"> 9.900000e-05 5.564000e-03 1.584000e-03 8.910000e-04 3.960000e-04 3.960000e-04 </matrix></covarianceMatrix></mixed>'
])
def parseXMLNode(element, xPath, linkData):
xPath.append(element.tag)
default = PQU.PQU(element.find('default').get('value'))
lvals = {}
for child in element:
if child.tag == 'Lspecific':
lval = int(child.get('L'))
lvals[lval] = PQU.PQU(child.get('value'))
result = LdependentScatteringRadii(default, lvals,
element.get('label'))
xPath.pop()
return result
def evaluateWithUncertainty(self,
E,
useCovariance=True,
covariance=None,
covarianceSuite=None):
"""
:param E:
:param useCovariance: use this to override covarance usage
:type useCovariance: bool
:param covariance:
:param covarianceSuite:
:return:
"""
import fudge.gnd.covariances.base as covModule
if (not isinstance(E, PQUModule.PQU)):
raise TypeError("E must be an PQUModule.PQU instance")
ptwise = self.hasLinearForm()
if ptwise is None:
ptwise = self.toPointwise_withLinearXYs(lowerEps=lowerEps,
upperEps=upperEps)
EinDomainUnit = E.getValueAs(ptwise.domainUnit)
if EinDomainUnit < ptwise.domainMin or EinDomainUnit > ptwise.domainMax:
meanValue = 0.0
else:
meanValue = ptwise.evaluate(EinDomainUnit)
# We might be done
if not useCovariance:
return PQUModule.PQU(meanValue, unit=ptwise.rangeUnit)
# Get that the covariance goes with the data.
covariance = self.getMatchingCovariance(covariance, covarianceSuite)
if covariance is None:
return PQUModule.PQU(meanValue, unit=ptwise.rangeUnit)
else:
try:
return (PQUModule.PQU(
meanValue,
unit=ptwise.rangeUnit,
uncertainty=covariance.getUncertaintyVector(
self.evaluated,
relative=False).evaluate(EinDomainUnit)))
except IndexError as err: # FIXME: a kludge until cov routines working again, try it on 27Al(n,tot)
print "WARNING: Could not extract uncertianty, got error %s" % str(
err)
return PQUModule.PQU(meanValue, unit=ptwise.rangeUnit)
def parseXMLNode(element, xPath, linkData):
xPath.append(element.tag)
value = PQU.PQU(element.get('value'))
bounds = None
if 'lowerBound' in element.keys():
bounds = tuple([
PQU.PQU(element.get(bound))
for bound in ('lowerBound', 'upperBound')
])
CSR = constantScatteringRadius(value,
bounds=bounds,
label=element.get('label'))
xPath.pop()
return CSR
def convert_units_to_energy(T, energyUnits='eV'):
if type(T) == str: T = PQU.PQU(T)
if not isinstance(T, PQU.PQU):
raise TypeError(
"argument to convert_units_to_energy must be a PQU, got type=%s" %
str(type(T)))
if T.isEnergy(): return T.inUnitsOf(energyUnits)
elif T.isTemperature():
return (T.inUnitsOf('K') *
PQU.PQU(8.6173324e-5, 'eV/K')).inUnitsOf(energyUnits)
# elif T.isMass(): return
# elif T.isLength(): return
# elif T.isTime(): return
else:
raise Exception("Cannot convert %s to energy units" % str(T))
def __init__(self,
particleLibrary,
projectile,
target,
library="ENDF/B",
version=None,
documentation=None,
transportables=['n']):
if version is None:
import datetime
version = datetime.datetime.today().strftime("%Y")
self.rs = gnd.reactionSuite.reactionSuite(
projectile,
target,
style=gnd.miscellaneous.style("evaluated", {
'library': library,
'version': version
}))
self.rs.addDocumentation(
gnd.documentation.documentation(
library, documentation or "skeleton for documentation"))
self.rs.setAttribute('temperature', PQU.PQU(0, 'K'))
self.rs.projectile.attributes['transportable'] = True
self.particleLibrary = particleLibrary
self.transportables = transportables
self.units = None
def parseXMLNode(productElement, xPath, linkData):
"""Translate a <product> element from xml."""
xPath.append('%s[@label="%s"]' %
(productElement.tag, productElement.get('label')))
attrs = dict(productElement.items())
prod = product(id=attrs.pop('name'), label=attrs.pop('label'))
prod.multiplicity.parseXMLNode(
productElement.find(multiplicityModule.component.moniker), xPath,
linkData)
prod.distribution.parseXMLNode(
productElement.find(distributionModule.component.moniker), xPath,
linkData)
outputChannel = productElement.find(channelsModule.outputChannelToken)
if (outputChannel):
prod.addOutputChannel(
channelsModule.parseXMLNode(outputChannel, xPath, linkData))
for attr in ('decayRate', 'primary', 'discrete'):
if (attr in attrs):
attrs[attr] = PQUModule.PQU(attrs[attr])
prod.attributes = attrs
depositionEnergyToken = energyDepositionModule.component.moniker
if (productElement.find(depositionEnergyToken) is not None):
prod.energyDeposition.parseXMLNode(
productElement.find(depositionEnergyToken), xPath, linkData)
depositionMomentumToken = momentumDepositionModule.component.moniker
if (productElement.find(depositionMomentumToken) is not None):
prod.momentumDeposition.parseXMLNode(
productElement.find(depositionMomentumToken), xPath, linkData)
xPath.pop()
return (prod)
def toENDF6(self, flags, targetInfo):
MF6 = [endfFormatsModule.endfContLine(0, 0, 0, 0, 1, len(self))]
EInInterpolation = gndToENDF6Module.gndToENDF2PlusDInterpolationFlag(
self.interpolation, self.interpolationQualifier)
energyConversionFactor = PQUModule.PQU(1,
self.axes[-1].unit).getValueAs('eV')
MF6 += endfFormatsModule.endfInterpolationList(
[len(self), EInInterpolation])
for oneEin in self:
muInterpolation = gndToENDF6Module.gndToENDF2PlusDInterpolationFlag(
self.interpolation, self.interpolationQualifier)
Ein = oneEin.value * energyConversionFactor
numMu = len(oneEin)
MF6 += [endfFormatsModule.endfContLine(0, Ein, 0, 0, 1, numMu)]
MF6 += endfFormatsModule.endfInterpolationList(
[numMu, muInterpolation])
for entries in oneEin:
pdf_of_EpInterpolation = gndToENDF6Module.gndToENDFInterpolationFlag(
self.interpolation)
mu = entries.value
numEout = len(entries)
MF6 += [endfFormatsModule.endfContLine(0, mu, 0, 0, 1, numEout)]
MF6 += endfFormatsModule.endfInterpolationList(
[numEout, pdf_of_EpInterpolation])
xys = entries.copyDataToXYs(xUnitTo='eV', yUnitTo='1/eV')
MF6 += endfFormatsModule.endfNdDataList(xys)
return (7, standardsModule.frames.labToken, MF6)
def integrateTwoFunctions(self, f2, domainMin=None, domainMax=None):
"""
:param f2:
:param domainMin:
:param domainMax:
:return:
"""
if (not isinstance(f2, XYs1d)):
raise TypeError("f2 must be an instance of an XYs1d")
unit = self.axes[xAxisIndex].unit
if (f2.axes[xAxisIndex].unit != unit):
f2 = f2.copy()
f2.convertAxisToUnit(xAxisIndex, unit)
domainMin, domainMax = baseModule.getDomainLimits(
self, domainMin, domainMax, unit)
domainMin = max(domainMin, self.domainMin, f2.domainMin)
domainMax = min(domainMax, self.domainMax, f2.domainMax)
return (PQU.PQU(pointwiseXY.groupTwoFunctions(self,
[domainMin, domainMax],
f2)[0],
baseModule.processUnits(
baseModule.processUnits(unit,
self.axes[yAxisIndex].unit,
'*'),
f2.axes[yAxisIndex].unit, '*'),
checkOrder=False))
def computeAstrophysicalReactionRate( xs, T, useCovariance=True, covariance=None ):
'''
The astrophysical reaction rate R is defined as :math:`R = N_A <\sigma v>`, where
:math:`N_A` is Avagadro's number. It is typically reported in units of [cm^3/mole s].
:param PQU T: temperature as a physical quantity
:param useCovariance: use this to override covarance usage
:type useCovariance: bool
:param covariance: covariance to use when computing uncertainty on the spectral average.
If None (default: None), no uncertainty is computed.
:type covariance: covariance instance or None
:rtype: PQU
.. warning:: Not implemented yet
'''
check_is_cross_section( xs )
if T is None: kT=convert_units_to_energy(ROOMTEMPERATURE)
else: kT=convert_units_to_energy(T)
m2 = xs.getRootAncestor().PoPs[xs.getRootAncestor().target].getMass('amu')
m1 = xs.getRootAncestor().PoPs[xs.getRootAncestor().projectile].getMass('amu')
mu = PQU.PQU(m1*m2/(m1+m2),'amu')
vT=(2.0*kT/mu).sqrt()
return (AVAGADROSNUMBER*computeMACS(xs,kT,useCovariance=useCovariance,covariance=covariance)*vT).inUnitsOf( "cm**3/mol/s" )
def convertUnit(unitFrom, unitTo, xs, xErrs, legend):
if unitTo is None: return None
if unitFrom is None: return None
unitFrom = unitFrom.replace('EV', 'eV')
if 'PER-CENT' in unitFrom: unitFrom = 'PERCENT'
elif 'no-dim' in unitFrom: unitFrom = ''
elif 'DEG-K' in unitFrom: unitFrom = 'K'
elif 'KeV' in unitFrom: unitFrom = 'keV'
unit = unitFrom
if ((unitFrom is not None) and (unitTo is not None)
and (unitFrom != unitTo)):
try:
conversionFactor = PQU.valueOrPQ(1.0,
unitFrom=unitFrom,
unitTo=unitTo,
asPQU=False)
except TypeError, err:
if legend is None: legend = "name suppressed"
raise TypeError("In plot2d.convertUnit, " + err.message +
', error from PQU: ' + unitFrom + ' -> ' + unitTo +
' for dataset ' + str(legend))
except NameError, err:
if legend is None: legend = "name suppressed"
raise NameError("In plot2d.convertUnit, " + err.message +
', error from PQU: ' + unitFrom + ' -> ' + unitTo +
' for dataset ' + str(legend))
def getColumnBounds(self,unit=None):
"""Get the bounds of the column. If unit is specified, return the bounds in that unit."""
if self.matrix.axes[-2].style=='link': return self.getRowBounds(unit)
factor = 1
if unit:
factor = PQU.PQU(1, self.matrix.axes[-1].unit).getValueAs(unit)
return( self.matrix.axes[-1].values[0] * factor, self.matrix.axes[-1].values[-1] * factor )
def convertUnits(self, unitMap):
unit, factor = PQUModule.convertUnits(self.unit, unitMap)
if (abs(factor - 1) > (4 * sys.float_info.epsilon)):
NotImplementedError(
'Conversion of units for quantity of "%s" not implemented: from unit "" to unit "%s"'
% (self.moniker, self.unit, unit))
def computeRI( xs, Ecut=None, domainMax=None, useCovariance=True, covariance=None ):
'''
Compute the resonance integral (RI):
.. math::
RI = \int_{Ec}^{\infty} \sigma(E) dE/E
Where the lower cut-off is usually taken to be the Cadmium cut-off energy of
Ecut = 0.5 eV (see S. Mughabghab, Atlas of Neutron Resonances). If the covariance
is provided, the uncertainty on the resonance integral will be computed.
:param PQU Ecut: lower bound of integration.
Usually taken to be the Cadmium cut-off energy (default: '0.5 eV')
:param PQU domainMax: an alternative upper energy integration cut-off used for cross checking against INTER mainly
:param useCovariance: use this to override covarance usage
:type useCovariance: bool
:param covariance: covariance to use when computing uncertainty on the spectral average.
If None (default: None), no uncertainty is computed.
:type covariance: covariance instance or None
:rtype: PQU
'''
check_is_cross_section( xs )
if Ecut is None:
return xs.integrateTwoFunctionsWithUncertainty( DEFAULTONEOVEREXYs, domainMax=domainMax, useCovariance=useCovariance, covariance=covariance, normalize=False )
Ecut = PQU.PQU(Ecut).getValueAs( xs.domainUnit )
# Construct an XYs instance that spans the same domain as self.
# The y values are all 1/E and the x values are all E.
def oneOverEFunc(E,*args):
if E < Ecut: return 0.0
return 1.0/E
Egrid=[1e-5,0.99999*Ecut]+list(equal_lethargy_bins(5000,domainMin=Ecut))
oneOverE = function_to_XYs( oneOverEFunc, [], Egrid=Egrid )
return xs.integrateTwoFunctionsWithUncertainty( oneOverE, domainMax=domainMax, useCovariance=useCovariance, covariance=covariance, normalize=False )
