def calculateAverageProductData(self, style, indent='', **kwargs): raise 'FIXME, when am I called' energyUnit = kwargs['incidentEnergyUnit'] momentumDepositionUnit = energyUnit + '/c' massUnit = energyUnit + '/c**2' energyAccuracy = kwargs['energyAccuracy'] momentumAccuracy = kwargs['momentumAccuracy'] product = kwargs['product'] reactionSuite = kwargs['reactionSuite'] if (product.name != 'gamma'): raise Exception( 'For form %s, calculateAverageProductData is only for gammas, not %s' % (self.moniker, product.name)) depData = [] angularSubform = self.angularSubform Es = angularSubform.getEnergyArray(kwargs['EMin'], kwargs['EMax']) if (('discrete' in product.attributes) or ('primary' in product.attributes)): massRatio = 0. if ('discrete' in product.attributes): Eg = product.attributes['discrete'].getValueAs(energyUnit) else: Eg = product.attributes['primary'].getValueAs(energyUnit) mass1 = reactionSuite.projectile.getMass(massUnit) mass2 = reactionSuite.target.getMass(massUnit) massRatio = mass2 / (mass1 + mass2) depEnergy = [[E, Eg + massRatio * E] for E in Es] depMomentum = [[ E, (Eg + massRatio * E) * angularSubform.averageMu(E, accuracy=0.1 * momentumAccuracy) ] for E in Es] else: raise Exception( 'Unsupported gamma; gamma must be "discrete" or "primary"') axes = energyDepositionModule.XYs1d.defaultAxes( energyUnit=energyUnit, energyDepositionUnit=energyUnit) depData.append( energyDepositionModule.XYs1d(data=depEnergy, axes=axes, label=style.label, accuracy=energyAccuracy)) axes = momentumDepositionModule.XYs1d.defaultAxes( energyUnit=energyUnit, momentumDepositionUnit=momentumDepositionUnit) depData.append( momentumDepositionModule.XYs1d(data=depMomentum, axes=axes, label=style.label, accuracy=momentumAccuracy)) return (depData)
def calculateAverageProductData( self, style, indent = '', **kwargs ) : from fudge.core.math import fudgemath def calculateDepositionMomentumAtMu( mu, parameters ) : f = ( mu - parameters.mu1 ) / ( parameters.mu2 - parameters.mu1 ) P_mu = ( 1 - f ) * parameters.P1 + f * parameters.P2 EpP = parameters.muEpPs.interpolateAtValue( mu, unitBase = True, extrapolation = standardsModule.flatExtrapolationToken ) Ep = EpP.integrateWithWeight_sqrt_x( ) return( mu * P_mu * Ep ) def calculateDepositionMomentum( muPs, muEpPs ) : class LLNLAngular_angularEnergy_MomentumParameters : def __init__( self, mu1, P1, mu2, P2, muEpPs ) : self.mu1, self.P1, self.mu2, self.P2, self.muEpPs = mu1, P1, mu2, P2, muEpPs def nextMu( self, m2, P2 ) : self.mu1, self.P1 = self.mu2, self.P2 self.mu2, self.P2 = mu2, P2 parameters = LLNLAngular_angularEnergy_MomentumParameters( 0, 0, 0, 0, muEpPs ) mu1, p = None, 0 for mu2, P2 in muPs : parameters.nextMu( mu2, P2 ) if( mu1 is not None ) : p += miscellaneousModule.GnG_adaptiveQuadrature( calculateDepositionMomentumAtMu, mu1, mu2, parameters, miscellaneousModule.GaussQuadrature2, tolerance = 1e-4 )[0] mu1 = mu2 return( p ) class calculateDepositionMomentumThicken : def __init__( self, angularSubform, angularEnergySubform, relativeTolerance, absoluteTolerance ) : self.angularSubform = angularSubform self.angularEnergySubform = angularEnergySubform self.relativeTolerance = relativeTolerance self.absoluteTolerance = absoluteTolerance def evaluateAtX( self, E ) : muPs = self.angularSubform.getAtEnergy( E ) muEpPs = self.angularEnergySubform.interpolateAtV( E, unitBase = True ) return( calculateDepositionMomentum( muPs, muEpPs ) ) energyUnit = kwargs['incidentEnergyUnit'] momentumDepositionUnit = kwargs['momentumDepositionUnit'] multiplicity = kwargs['multiplicity'] energyAccuracy = kwargs['energyAccuracy'] momentumAccuracy = kwargs['momentumAccuracy'] product = kwargs['product'] productMass = kwargs['productMass'] angularSubform = self.angularSubform.data angularEnergySubform = self.angularEnergySubform.data depEnergy = miscellaneousModule.calculateDepositionEnergyFromAngular_angularEnergy( style, angularSubform, angularEnergySubform, multiplicity, accuracy = energyAccuracy ) if( product.id == IDsPoPsModule.photon ) : depMomentum = miscellaneousModule.calculateDepositionEnergyFromAngular_angularEnergy( style, angularSubform, angularEnergySubform, multiplicity, True, accuracy = momentumAccuracy ) else : relativeTolerance, absoluteTolerance = momentumAccuracy, momentumAccuracy depMomentum = [] for indexE, muPs in enumerate( angularSubform ) : depMomentum.append( [ muPs.value, calculateDepositionMomentum( muPs, angularEnergySubform[indexE] ) ] ) # depMomentum = fudgemath.thickenXYList( depMomentum, calculateDepositionMomentumThicken( angularSubform, angularEnergySubform, relativeTolerance, absoluteTolerance ) ) const = math.sqrt( 2. * productMass ) for EMomenutem in depMomentum : EMomenutem[1] *= const * multiplicity.evaluate( EMomenutem[0] ) axes = momentumDepositionModule.defaultAxes( energyUnit = energyUnit, momentumDepositionUnit = momentumDepositionUnit ) depMomentum = momentumDepositionModule.XYs1d( data = depMomentum, axes = axes, label = style.label ) return( [ depEnergy ], [ depMomentum ] )
def calculateAverageProductData(self, style, indent='', **kwargs): verbosity = kwargs.get('verbosity', 0) indent2 = indent + kwargs.get('incrementalIndent', ' ') energyUnit = kwargs['incidentEnergyUnit'] momentumDepositionUnit = kwargs['momentumDepositionUnit'] multiplicity = kwargs['multiplicity'] productMass = kwargs['productMass'] energyAccuracy = kwargs['energyAccuracy'] momentumAccuracy = kwargs['momentumAccuracy'] EMin = kwargs['EMin'] Legendre_l0, Legendre_l1 = self[0], None if (len(self) > 1): Legendre_l1 = self[1] if (isinstance(multiplicity, multiplicityModule.XYs1d) ): # If multiplicity as points not in Legendre_l0 add them. Es = set([EpP.value for EpP in Legendre_l0]) for E, m in multiplicity: Es.add(E) if (len(Es) > len(Legendre_l0)): Es = sorted(Es) Legendre_l0p = multiD_XYsModule.XYs2d() for energy in Es: Legendre_l0p.append( Legendre_l0.interpolateAtValue( energy, unitBase=True, extrapolation=standardsModule. flatExtrapolationToken)) Legendre_l0 = Legendre_l0p if (Legendre_l1 is not None): Legendre_l1p = multiD_XYsModule.XYs2d() for energy in Es: Legendre_l1p.append( Legendre_l1.interpolateAtValue( energy, unitBase=True, extrapolation=standardsModule. flatExtrapolationToken)) Legendre_l1 = Legendre_l1p calculateDepositionEnergyFromEpP = miscellaneousModule.calculateDepositionEnergyFromEpP depEnergy = [[ EpP.value, multiplicity.evaluate(EpP.value) * calculateDepositionEnergyFromEpP(EpP.value, EpP) ] for EpP in Legendre_l0] if (depEnergy[0][0] > EMin): depEnergy.insert(0, [EMin, 0.]) # Special case for bad data axes = energyDepositionModule.defaultAxes(energyUnit) energyDep = energyDepositionModule.XYs1d(data=depEnergy, axes=axes, label=style.label) if (Legendre_l1 is not None): depMomentum = [] const = math.sqrt(2. * productMass) for EpP in Legendre_l1: if (const == 0): # For gammas. depMomentum.append([ EpP.value, multiplicity.evaluate(EpP.value) * EpP.integrateWithWeight_x() ]) else: depMomentum.append([ EpP.value, const * multiplicity.evaluate(EpP.value) * EpP.integrateWithWeight_sqrt_x() ]) else: depMomentum = [[Legendre_l0[0].value, 0.], [Legendre_l0[-1].value, 0.]] axes = momentumDepositionModule.defaultAxes(energyUnit, momentumDepositionUnit) if (depMomentum[0][0] > EMin): depMomentum.insert(0, [EMin, 0.]) # Special case for bad data momentumDep = momentumDepositionModule.XYs1d(data=depMomentum, axes=axes, label=style.label) return ([energyDep], [momentumDep])
def calculateDepositionData(self, style, indent='', **kwargs): verbosity = kwargs.get('verbosity', 0) indent2 = indent + kwargs.get('incrementalIndent', ' ') energyUnit = kwargs['incidentEnergyUnit'] momentumDepositionUnit = energyUnit + '/c' massUnit = energyUnit + '/c**2' multiplicity = kwargs['multiplicity'] productMass = kwargs['product'].getMass(massUnit) energyAccuracy = kwargs['energyAccuracy'] momentumAccuracy = kwargs['momentumAccuracy'] EMin = kwargs['EMin'] depData = [] Legendre_l0, Legendre_l1 = self[0], None if (len(self) > 1): Legendre_l1 = self[1] if (isinstance(multiplicity, multiplicityModule.XYs1d)): Es = [EpP.value for EpP in Legendre_l0] doIt = False for E, m in multiplicity.getFormByToken( tokensModule.pointwiseFormToken): if (E < Es[0]): continue if (E not in Es): doIt = True Es.append(E) if (doIt): Es.sort() Legendre_l0p, Legendre_l1p = LLNLPointwiseEEpP( 0), LLNLPointwiseEEpP(1) indexE, EpP1 = 0, None for EpP2 in Legendre_l0: while ((indexE < len(Es)) and (EpP2.value > Es[indexE])): if (EpP1.value != Es[indexE]): EpP = XYs.pointwiseXY_C.unitbaseInterpolate( Es[indexE], EpP1.value, EpP1, EpP2.value, EpP2) axes = EpP1.axes.copy() Legendre_l0p.append( XYs.XYs(axes, EpP, EpP1.getAccuracy(), value=Es[indexE])) indexE += 1 Legendre_l0p.append(EpP2) EpP1 = EpP2 Legendre_l0 = Legendre_l0p if (Legendre_l1 is not None): for EpP2 in Legendre_l1: while ((indexE < len(Es)) and (EpP2.value > Es[indexE])): if (EpP1 is None): raise Exception( 'multiplicity energy = %s before Legendre l = 0 distribution energy = %s' % (Es[indexE], EpP2.value)) if (EpP1.value != Es[indexE]): EpP = XYs.pointwiseXY_C.unitbaseInterpolate( Es[indexE], EpP1.value, EpP1, EpP2.value, EpP2) axes = EpP1.axes.copy() Legendre_l1p.append( XYs.XYs(axes, EpP, EpP1.getAccuracy(), value=Es[indexE])) indexE += 1 Legendre_l1p.append(EpP2) EpP1 = EpP2 Legendre_l1 = Legendre_l1p depEnergy = [[ EpP.value, multiplicity.getValue(EpP.value) * miscellaneous.calculateDepositionEnergyFromEpP(EpP.value, EpP) ] for EpP in Legendre_l0] if (depEnergy[0][0] > EMin): depEnergy.insert(0, ['EMin', 0.]) # Special case for bad data axes = energyDepositionModule.XYs1d.defaultAxes( energyUnit=energyUnit, energyDepositionUnit=energyUnit) depData.append( energyDepositionModule.XYs1d(data=depEnergy, axes=axes, label=style.label, accuracy=energyAccuracy)) if (Legendre_l1 is not None): const = math.sqrt(2. * productMass) if (const == 0.): const = 1 # For gammas. depMomentum = [] EpP = Legendre_l1[0] for EpP in Legendre_l1: if (const == 0.): # For gammas. depMomentum.append([ EpP.value, const * multiplicity.getValue(EpP.value) * EpP.integrateWithWeight_x() ]) else: depMomentum.append([ EpP.value, const * multiplicity.getValue(EpP.value) * EpP.integrateWithWeight_sqrt_x() ]) else: depMomentum = [[Legendre_l0[0].value, 0.], [Legendre_l0[-1].value, 0.]] axes = momentumDepositionModule.XYs1d.defaultAxes( energyUnit=energyUnit, momentumDepositionUnit=momentumDepositionUnit) if (depMomentum[0][0] > EMin): depMomentum.insert(0, [EMin, 0.]) # Special case for bad data depData.append( momentumDepositionModule.XYs1d(data=depMomentum, axes=axes, label=style.label, accuracy=momentumAccuracy)) return (depData)