def defaultAxes(energyUnit, momentumDepositionUnit): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis('averageProductMomentum', 0, momentumDepositionUnit) axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def defaultAxes( energyUnit ) : axes = axesModule.axes( ) # BRB6 make 'energy_in' a token axes[1] = axesModule.axis( 'energy_in', 0, energyUnit ) axes[0] = axesModule.axis( component.moniker, 1, energyUnit ) return( axes )
def getW_XYs(self): from xData import axes as axesModule from xData import XYs as XYsModule from xData import multiD_XYs as multiD_XYsModule xUnit, yUnit, zUnit = '', '', '' if (self.xUnit is not None): xUnit = self.xUnit if (self.yUnit is not None): yUnit = self.yUnit if (self.zUnit is not None): zUnit = self.zUnit axes_3d = axesModule.axes(3) axes_3d[0] = axesModule.axis('z', 0, zUnit) axes_3d[1] = axesModule.axis('y', 0, yUnit) axes_3d[2] = axesModule.axis('x', 0, xUnit) w_xys = multiD_XYsModule.multiD_XYs(axes=axes_3d) axes_2d = axesModule.axes() axes_2d[0] = axes_3d[0] axes_2d[1] = axes_3d[1] for ix, x in enumerate(self.x): xys = [[y, self.z[iy][ix]] for iy, y in enumerate(self.y)] w_xys[ix] = XYsModule.XYs(xys, axes=axes_2d, accuracy=1e-3, value=x) return (w_xys)
def defaultAxes(energyUnit='eV', crossSectionUnit='b'): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis(baseModule.crossSectionToken, 0, crossSectionUnit) axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def defaultAxes(energyUnit): axes = axesModule.axes(rank=3) axes[0] = axesModule.axis('P(mu|energy_in)', 0, '') axes[1] = axesModule.axis('mu', 1, '') axes[2] = axesModule.axis('energy_in', 2, energyUnit) return (axes)
def defaultAxes(): axes = axesModule.axes(rank=4) axes[0] = axesModule.axis('c_l', 0, '1/MeV') axes[1] = axesModule.axis('energy_out', 1, 'MeV') axes[2] = axesModule.axis('energy_in', 2, 'MeV') axes[3] = axesModule.axis('l', 3, '') return (axes)
def defaultAxes(energyUnit='eV'): axes = axesModule.axes(rank=3) axes[0] = axesModule.axis('P(energy_out|energy_in)', 0, '1/' + energyUnit) axes[1] = axesModule.axis('energy_out', 1, energyUnit) axes[2] = axesModule.axis('energy_in', 2, energyUnit) return (axes)
def defaultAxes(energyUnit): axes = axesModule.axes(rank=4) axes[3] = axesModule.axis('l', 3, '') axes[2] = axesModule.axis('energy_in', 2, energyUnit) axes[1] = axesModule.axis('energy_out', 1, energyUnit) axes[0] = axesModule.axis('c_l', 0, '1/' + energyUnit) return (axes)
def defaultAxes( energyUnit, probabilityLabel = 'P(mu,energy_out|energy_in)' ) : axes = axesModule.axes( rank = 4 ) axes[3] = axesModule.axis( 'energy_in', 3, energyUnit ) axes[2] = axesModule.axis( 'mu', 2, '' ) axes[1] = axesModule.axis( 'energy_out', 1, energyUnit ) axes[0] = axesModule.axis( probabilityLabel, 0, '1/' + energyUnit ) return( axes )
def defaultAxes(energyUnit='eV', momentumDepositionName=averageProductMomentumToken, momentumDepositionUnit='eV/c'): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis(momentumDepositionName, 0, momentumDepositionUnit) axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def defaultAxes( moniker ) : axes = axesModule.axes( rank = 3 ) axes[2] = axesModule.axis( 'energy_in', 2, 'eV' ) axes[1] = axesModule.axis( 'energy_out', 1, 'eV' ) x0Unit = '' if( moniker == 'f' ) : x0Unit = '1/eV' axes[0] = axesModule.axis( moniker, 0, x0Unit ) return( axes )
def defaultAxes(energyUnit='eV', energyDepositionName=averageProductEnergyToken, energyDepositionUnit=None): if (energyDepositionUnit is None): energyDepositionUnit = energyUnit axes = axesModule.axes(rank=2) axes[0] = axesModule.axis(energyDepositionName, 0, energyDepositionUnit) axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def calculateDepositionEnergyFromEpP(E, EpP): "EpP is a list of [ E', P(E') ]" axes = axesModule.axes() axes[0] = axesModule.axis('a', 0, EpP.axes[0].unit) axes[1] = axesModule.axis('b', 1, EpP.axes[1].unit) Ep = XYsModule.XYs1d(data=[[EpP[0][0], EpP[0][0]], [EpP[-1][0], EpP[-1][0]]], axes=axes) return (float(EpP.integrateTwoFunctions(Ep)))
def defaultAxes(moniker, energyUnit): axes = axesModule.axes(rank=3) axes[2] = axesModule.axis('energy_in', 2, energyUnit) axes[1] = axesModule.axis('energy_out', 1, energyUnit) if (moniker == 'f'): axes[0] = axesModule.axis(moniker, 0, '1/' + energyUnit) else: axes[0] = axesModule.axis(moniker, 0, '') return (axes)
def defaultAxes(energyUnit='eV', probabilityUnit='', asLegendre=False): axes = axesModule.axes(rank=3) if (asLegendre): axes[0] = axesModule.axis('C_l(energy_in)', 0, '') axes[1] = axesModule.axis('l', 1, '') else: axes[0] = axesModule.axis('P(mu|energy_in)', 0, probabilityUnit) axes[1] = axesModule.axis('mu', 1, '') axes[2] = axesModule.axis('energy_in', 2, energyUnit) return (axes)
def defaultAxes(energyUnit='eV', energy_outUnit='eV', probabilityUnit='1/eV'): axes = axesModule.axes(rank=4) axes[0] = axesModule.axis('P(mu,energy_out|energy_in)', 0, probabilityUnit) axes[1] = axesModule.axis('mu', 1, '') axes[2] = axesModule.axis('energy_out', 2, energy_outUnit) axes[3] = axesModule.axis('energy_in', 3, energyUnit) return (axes)
def toMultiGroup1d( cls, style, tempInfo, _axes, data, addLabel = True ) : """ This function takes 1-d multi-group data as a list of floats and return to 1-d gridded instance containing the multi-group data. The list of data must contain n values where n is the number of groups. """ reactionSuite = tempInfo['reactionSuite'] axes = axesModule.axes( rank = 2 ) axes[0] = axesModule.axis( _axes[0].label, 0, _axes[0].unit ) energyInGrid = style.transportables[reactionSuite.projectile].group.boundaries.values.copy( ) axes[1] = axesModule.grid( _axes[1].label, 1, _axes[1].unit, axesModule.boundariesGridToken, energyInGrid ) shape = [ len( data ) ] data = valuesModule.values( data ) for start, datum in enumerate( data ) : if( datum != 0 ) : break end = 0 for i1, datum in enumerate( data ) : if( datum != 0 ) : end = i1 if( start > end ) : # Only happens when all values are 0. start = 0 else : end += 1 data = data[start:end] starts = valuesModule.values( [ start ], valueType = standardsModule.types.integer32Token ) lengths = valuesModule.values( [ len( data ) ], valueType = standardsModule.types.integer32Token ) flattened = arrayModule.flattened( shape = shape, data = data, starts = starts, lengths = lengths ) label = None if( addLabel ) : label = style.label return( cls( label = label, axes = axes, array = flattened ) )
def groupFunctionCrossSectionAndFlux(cls, style, tempInfo, f1, printMutualDomainWarning=False): crossSection = tempInfo['crossSection'] norm = tempInfo['groupedFlux'] grouped = groupTwoFunctionsAndFlux( style, tempInfo, f1, crossSection, norm=norm, printMutualDomainWarning=printMutualDomainWarning) unit = crossSection.axes[0].unit if (f1.axes[0].unit != ''): unit = '%s * %s' % (f1.axes[0].unit, unit) axis = axesModule.axis(label='%s * %s' % (f1.axes[0].label, crossSection.axes[0].label), unit=unit, index=0) axes = f1.axes.copy() axes[0] = axis return (groupModule.toMultiGroup1d(cls, style, tempInfo, axes, grouped))
def TMs2Form( style, tempInfo, TM_1, TM_E ) : from fudge.processing import transportables as transportablesModule from fudge.gnd.productData.distributions import multiGroup as multiGroupModule reactionSuite = tempInfo['reactionSuite'] productName = tempInfo['productName'] transportable = style.transportables[productName] conserve = transportable.conserve energyUnit = tempInfo['incidentEnergyUnit'] # BRB hardwired. crossSectionUnit = 'b' # ?????? 'b' should not be hardwired. axes = axesModule.axes( rank = 4 ) axes[0] = axesModule.axis( 'C_l(energy_in,energy_out)', 0, crossSectionUnit ) lMaxPlus1 = len( TM_1[0][0] ) lGrid = valuesModule.values( [ i1 for i1 in range( lMaxPlus1 ) ], valueType = standardsModule.types.integer32Token ) axes[1] = axesModule.grid( 'l', 1, '', axesModule.parametersGridToken, lGrid ) energyOutGrid = style.transportables[productName].group.boundaries.values.copy( ) axes[2] = axesModule.grid( 'energy_out', 2, energyUnit, axesModule.boundariesGridToken, energyOutGrid ) energyInGrid = style.transportables[reactionSuite.projectile].group.boundaries.values.copy( ) axes[3] = axesModule.grid( 'energy_in', 3, energyUnit, axesModule.boundariesGridToken, energyInGrid ) if( conserve == transportablesModule.conserve.number ) : TM = TM_1 else : raise NotImplementedError( 'Need to implement' ) n1 = len( TM ) n2 = len( TM[0] ) n3 = len( TM[0][0] ) data, starts, lengths = [], [], [] for i1 in sorted( TM.keys( ) ) : TM_i1 = TM[i1] start, length = None, 0 for i2 in sorted( TM_i1.keys( ) ) : TM_i1_i2 = TM_i1[i2] cellMin = min( TM_i1_i2 ) cellMax = max( TM_i1_i2 ) if( ( cellMin != 0 ) or ( cellMax != 0 ) ) : if( start is None ) : start = n3 * ( n2 * i1 + i2 ) length += n3 data += TM_i1_i2 else : if( start is not None ) : starts.append( start ) lengths.append( length ) start, length = None, 0 if( start is not None ) : starts.append( start ) lengths.append( length ) shape = [ n1, n2, n3 ] data = valuesModule.values( data ) starts = valuesModule.values( starts, valueType = standardsModule.types.integer32Token ) lengths = valuesModule.values( lengths, valueType = standardsModule.types.integer32Token ) flattened = arrayModule.flattened( shape = shape, data = data, starts = starts, lengths = lengths, dataToString = multiGroupModule.gridded3d.dataToString ) gridded3d = multiGroupModule.gridded3d( axes = axes, array = flattened ) return( multiGroupModule.form( style.label, standardsModule.frames.labToken, gridded3d ) )
def __init__(self, angularEnergy_): self.productFrame = angularEnergy_.getProductFrame() axes_ = axes.defaultAxes(3) axes_[0] = angularEnergy_.axes[0] axes_[1] = angularEnergy_.axes[1] axes_[2] = axes.axis("P(mu|energy_in)", 2, "") W_XYs.W_XYs.__init__(self, axes_) for w_xys in angularEnergy_: P_mu = [[xys.value, xys.integrate()] for xys in w_xys] self.append( XYs.XYs(XYs.XYs.defaultAxes(), P_mu, 1e-3, value=w_xys.value))
def get_ENDF_flux(file, mat, mf, mt): import fudge.legacy.converting.ENDFToGND.endfFileToGNDMisc as endfFileToGNDMiscModule import xData.axes as axesModule import xData.XYs as XYsModule # Grab the data corresponding to the spectrum MF3Data = [ line.strip('\r\n') for line in open(file).readlines() if int(line[67:70]) == int(mat) and int(line[70:72]) == int(mf) and int(line[72:75]) == int(mt) ] # Define the axes spectrumAxes = axesModule.axes(rank=2) spectrumAxes[0] = axesModule.axis('spectrum', 0, '1/eV') spectrumAxes[1] = axesModule.axis('energy_in', 1, 'eV') # Now make the spectrum as an XYs1d dataLine, TAB1, spectrumRegions = endfFileToGNDMiscModule.getTAB1Regions( 1, MF3Data, allowInterpolation6=True, logFile=None, #info.logs, axes=spectrumAxes, cls=XYsModule.XYs1d) if (len(spectrumRegions) == 1): # Store as XYs1d. spectrumForm = XYsModule.XYs1d( data=spectrumRegions[0], label=None, axes=spectrumAxes, interpolation=spectrumRegions[0].interpolation) else: raise NotImplementedError( "Fluxes with multiple regions for %s/%s/%s/%s" % (file, mat, mf, mt)) spectrumForm = crossSectionModule.regions1d(label=None, axes=spectrumAxes) for region in spectrumRegions: if (len(region) > 1): spectrumForm.append(region) return (spectrumForm)
def multiGroupInverseSpeed(style, tempInfo): _groupBoundaries, flux = miscellaneousModule._groupFunctionsAndFluxInit( style, tempInfo, None) groupBoundaries = _groupBoundaries.values.values # cm/sh const = 2. / (3. * math.sqrt(2) * 2.99792458e+02 ) # BRB - speed-of-light should not be hardwired. const *= math.sqrt( float(PQUModule.PQU(1, 'MeV').convertToUnit(_groupBoundaries.unit))) const *= math.sqrt( tempInfo['projectileMass']) # Mass is in energy unit / c^2. numberOfGroups = len(groupBoundaries) - 1 E1 = groupBoundaries[0] inverseSpeeds = [] for i1 in range(numberOfGroups): E2 = groupBoundaries[i1 + 1] fluxSlice = flux.domainSlice(domainMin=E1, domainMax=E2, fill=True) fluxIntegral = 0 inverseSpeedIntegral = 0 _E1 = None for _E2, _flux2 in fluxSlice: if (_E1 is not None): fluxIntegral += (_E2 - _E1) * (_flux2 + _flux1) x1 = math.sqrt(_E1) x2 = math.sqrt(_E2) inverseSpeedIntegral += (x2 - x1) * (_flux1 + _flux2 + (_flux1 * x2 + _flux2 * x1) / (x1 + x2)) _E1 = _E2 _flux1 = _flux2 inverseSpeed = 0 if (fluxIntegral != 0): inverseSpeed = const * inverseSpeedIntegral / (fluxIntegral / 2) inverseSpeeds.append(inverseSpeed) E1 = E2 axes = axesModule.axes(rank=2) axes[0] = axesModule.axis(label="inverse speed", unit="sh/cm", index=0) axes[1] = flux.axes[1] return (groupModule.toMultiGroup1d(gridded1d, style, tempInfo, axes, inverseSpeeds, addLabel=False))
def __init__( self, angularEnergy ) : self.__productFrame = angularEnergy.productFrame axes = axesModule.defaultAxes( 3 ) axes2d[2] = angularEnergy.axes[2] axes2d[1] = angularEnergy.axes[1] axes2d[0] = axesModule.axis( "P(mu|energy_in)", 0, "" ) axes1d = XYsModule.XYs1d.defaultAxes( ) axes1d[0] = axes2d[0] axes1d[1] = axes2d[1] multiD_XYsModule.XYs2d.__init__( self, axes = axes2d ) for P_EpGivenMu in angularEnergy : P_mu = [ [ xys.value, xys.integrate( ) ] for xys in P_EpGivenMu ] self.append( XYsModule.XYs1d( data = P_mu, axes = axes1d, accuracy = 1e-3, value = P_EpGivenMu.value ) )
def calculate_a( self, energy_in, energy_out_cmMin, energy_out_cmMax, accuracy = 1e-6 ) : from fudge.core.math import fudgemath from fudge.particles import nuclear def getParticleData( particle ) : Z, A, suffix, ZA = particle.getZ_A_SuffixAndZA( ) return( particle.name, Z, max( 0, A - Z ), A, particle.getMass( 'MeV/c**2' ) ) energyFactor = PQU.PQU( 1, 'MeV' ).getValueAs( self.fSubform.data.axes[-1].unit ) projectile = self.findAttributeInAncestry( 'projectile' ) target = self.findAttributeInAncestry( 'target' ) product = self.findClassInAncestry( fudge.gnd.product.product ).particle name_a, Z_a, N_a, A_a, AWRa = getParticleData( projectile ) name_A, Z_A, N_A, A_A, AWRA = getParticleData( target ) name_b, Z_b, N_b, A_b, AWRb = getParticleData( product ) Z_C, N_C = Z_a + Z_A, N_a + N_A if( N_A == 0 ) : N_C = 0 Z_B, N_B = Z_C - Z_b, max( 0, N_C - N_b ) A_B = Z_B + N_B if( N_B == 0 ) : A_B = 0 particles = self.findClassInAncestry( fudge.gnd.reactionSuite.reactionSuite ).particles residual = particles.getParticle( nuclear.nucleusNameFromZA( 1000 * Z_B + A_B ) ) AWRB = residual.getMass( 'MeV/c**2' ) Ma, Ia = self.KalbachMann_a_parameters[name_a]['M'], self.KalbachMann_a_parameters[name_a]['I'] mb, Ib = self.KalbachMann_a_parameters[name_b]['m'], self.KalbachMann_a_parameters[name_b]['I'] Sa, Sb = energyFactor * self.calculate_S_ab_MeV( Z_A, N_A, Z_C, N_C, Ia ), energyFactor * self.calculate_S_ab_MeV( Z_B, N_B, Z_C, N_C, Ib ) C1, C2, C3 = 0.04 / energyFactor, 1.8e-6 / energyFactor**3, 6.7e-7 / energyFactor**4 ea = energy_in * AWRA / ( AWRa + AWRA ) + Sa R1, R3 = 130 * energyFactor, 41 * energyFactor # MeV to self's energy units. if( ea < R1 ) : R1 = ea if( ea < R3 ) : R3 = ea def calculate_a2( energy_out_cm ) : eb = energy_out_cm * ( AWRb + AWRB ) / AWRB + Sb X1, X3 = R1 * eb / ea, R3 * eb / ea return( X1 * ( C1 + C2 * X1 * X1 ) + C3 * Ma * mb * X3**4 ) class thicken_a : def __init__( self, calculate_a2, relativeTolerance, absoluteTolerance ) : self.calculate_a2 = calculate_a2 self.relativeTolerance = relativeTolerance self.absoluteTolerance = absoluteTolerance def evaluateAtX( self, x ) : return( self.calculate_a2( x ) ) a = [ [ energy_out_cmMin, calculate_a2( energy_out_cmMin ) ], [ energy_out_cmMax, calculate_a2( energy_out_cmMax ) ] ] a = fudgemath.thickenXYList( a, thicken_a( calculate_a2, accuracy, 1e-10 ) ) axes = axesModule.axes( ) axes[0] = axesModule.axis( 'a', 0, '' ) axes[1] = self.fSubform.data.axes[1].copy( ) return( XYsModule.XYs1d( data = a, axes = axes, accuracy = accuracy ) )
def defaultAxes( factorLabel, energyUnit ) : axes = axesModule.axes( rank = 2 ) axes[0] = axesModule.axis( factorLabel, 0, "" ) axes[1] = axesModule.axis( 'energy_in', 1, energyUnit ) return( axes )
def defaultAxes(energyUnit): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis('multiplicity', 0, '') axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def defaultAxes(energyUnit): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis('energy_out', 0, energyUnit) axes[1] = axesModule.axis('energy_in', 1, energyUnit) return (axes)
def defaultAxes(): axes = axesModule.axes(rank=2) axes[0] = axesModule.axis('energy_loss(energy_in)', 0, 'eV') axes[1] = axesModule.axis('energy_in', 1, 'eV') return (axes)
def toCovarianceMatrix(self, label="composed"): """ Sum all parts together to build a single matrix. """ if len(self.components) == 1: return self.components[0].toCovarianceMatrix() import fudge.gnd.covariances.base as base import numpy import xData.values as valuesModule import xData.array as arrayModule # Set up common data using first component firstCovMtx = self.components[0].toCovarianceMatrix() if not isinstance(firstCovMtx, base.covarianceMatrix): raise TypeError( "Shoudd have gotten base.covarianceMatrix, instead got %s" % str(firstCovMtx.__class__)) commonRowAxis = firstCovMtx.matrix.axes[2].copy( []) #FIXME: unresolvedLinks are still unresolved! if firstCovMtx.matrix.axes[1].style == 'link': commonColAxis = firstCovMtx.matrix.axes[2].copy( []) #FIXME: unresolvedLinks are still unresolved! else: commonColAxis = firstCovMtx.matrix.axes[1].copy( []) #FIXME: unresolvedLinks are still unresolved! commonMatrixAxis = firstCovMtx.matrix.axes[0].copy( []) #FIXME: unresolvedLinks are still unresolved! commonType = firstCovMtx.type # We need all the covariances to be either absolute or relative def make_common_type(cm): if commonType == 'relative': return cm.toRelative() else: return cm.toAbsolute() # We're going to have to merge grids, so we'll need this function to do the dirty work def add_values(v1, v2): v = set() v.update(v1.values) v.update(v2.values) return valuesModule.values(sorted(v)) # First pass through components is to collect bins to set up the common grid + do assorted checking for c in self.components[1:]: cc = make_common_type(c.toCovarianceMatrix( )) # a little recursion to take care of nested covariances if cc.type != commonType: raise ValueError("Incompatible types in %s: %s vs. %s" % (self.__class__, commonType, cc.type)) if cc.matrix.axes[0].unit != commonMatrixAxis.unit: raise ValueError( "covariance matrix components with different units?!? %s vs. %s" % (cc.matrix.axes[0].unit, commonMatrixAxis.unit)) if cc.matrix.axes[1].style != 'link': cc.matrix.axes[1].convertToUnit(commonColAxis.unit) cc.matrix.axes[2].convertToUnit(commonRowAxis.unit) commonRowAxis.values.values = add_values(commonRowAxis.values, cc.matrix.axes[2].values) if cc.matrix.axes[1].style == 'link': commonColAxis.values.values = add_values( commonColAxis.values, cc.matrix.axes[2].values) else: commonColAxis.values.values = add_values( commonColAxis.values, cc.matrix.axes[1].values) # Now sum up the components commonMatrix = numpy.mat( firstCovMtx.group( (commonRowAxis.values.values, commonColAxis.values.values), (commonRowAxis.unit, commonColAxis.unit)).matrix.array.constructArray()) for c in self.components[1:]: cc = make_common_type(c.toCovarianceMatrix( )) # a little recursion to take care of nested covariances commonMatrix += numpy.mat( cc.group( (commonRowAxis.values.values, commonColAxis.values.values), (commonRowAxis.unit, commonColAxis.unit)).matrix.array.constructArray()) # Now create the instance of the resulting covarianceMatrix if all([ component.toCovarianceMatrix().matrix.axes[1].style == 'link' for component in self.components ]): commonColAxis = self.components[0].toCovarianceMatrix( ).matrix.axes[1].copy( []) #FIXME: unresolvedLinks are still unresolved! newAxes = axesModule.axes( labelsUnits={ 0: (commonMatrixAxis.label, commonMatrixAxis.unit), 1: (commonColAxis.label, commonColAxis.unit), 2: (commonRowAxis.label, commonRowAxis.unit) }) newAxes[2] = axesModule.grid(commonRowAxis.label, commonRowAxis.index, commonRowAxis.unit, style=axesModule.boundariesGridToken, values=commonRowAxis.values) newAxes[1] = axesModule.grid(commonColAxis.label, commonColAxis.index, commonColAxis.unit, style=axesModule.linkGridToken, values=linkModule.link( link=commonRowAxis.values, relative=True)) newAxes[0] = axesModule.axis(commonMatrixAxis.label, commonMatrixAxis.index, commonMatrixAxis.unit) trigdata = commonMatrix[numpy.tri(commonMatrix.shape[0]) == 1.0].tolist()[0] gridded = griddedModule.gridded2d( axes=newAxes, array=arrayModule.full(shape=commonMatrix.shape, data=trigdata, symmetry=arrayModule.symmetryLowerToken)) newCov = base.covarianceMatrix(label=label, type=commonType, matrix=gridded) newCov.setAncestor(self.ancestor) return newCov
def toENDF6(self, MT, endfMFList, flags, targetInfo): """ In ENDF MF=6, some distributions should really be treated as uncorrelated: NBodyPhaseSpace, and also Legendre expansions when only L=0 is listed. For GND we split these into uncorrelated angular (isotropic) and energy distributions. Must put back in original format when writing back to ENDF. """ frame = self.productFrame energySubform = self.energySubform.data angularSubform = self.angularSubform.data if (isinstance(energySubform, energyModule.NBodyPhaseSpace)): energySubform.toENDF6(MT, endfMFList, flags, targetInfo) elif (targetInfo['doMF4AsMF6']): if (isinstance( energySubform, (energyModule.discreteGamma, energyModule.primaryGamma))): # BRB - this needs to be checked. if (targetInfo['product'].id != IDsPoPsModule.photon): raise ValueError('This logic is only for discrete gammas') energyForm = energyModule.form(self.label, frame, energySubform) angularForm = angularModule.form(self.label, frame, angularSubform) energyForm.toENDF6(MT, endfMFList, flags, targetInfo) angularForm.toENDF6(MT, endfMFList, flags, targetInfo) elif (isinstance(angularSubform, angularModule.isotropic) ): # Change to energyAngular with Legendre if (not (isinstance(energySubform, energyModule.XYs2d))): raise 'hell - fix me' axes = axesModule.axes(rank=4) axes[3] = axesModule.axis('energy_in', 3, 'eV') axes[2] = axesModule.axis('energy_out', 2, 'eV') axes[1] = axesModule.axis('l', 1, '') axes[0] = axesModule.axis('C_l(energy_out|energy_in)', 0, '1/eV') energyAngularSubform = energyAngularModule.XYs3d( axes=axes, interpolation=energySubform.interpolation, interpolationQualifier=energySubform.interpolationQualifier) EInFactor = PQUModule.PQU( 1, energySubform.axes[2].unit).getValueAs('eV') for EIn in energySubform: if isinstance(EIn, regionsModule.regions1d): # writing to MF6 LAW=1, LANG=1 doesn't support multiple regions, must recombine. if (len(set([ein.interpolation for ein in EIn])) != 1): raise NotImplemented, "ENDF MF6 LAW=1 LANG=1 doesn't support multiple E' interpolations!" xyvals = EIn[0].copyDataToXYs() for region in EIn[1:]: xynew = region.copyDataToXYs() xynew[0][0] *= 1.00000001 xyvals.extend(xynew) EIn_copy = EIn[0].copy() EIn_copy.value = EIn.value EIn_copy.axes = EIn.axes.copy() EIn_copy.setData(xyvals) EIn = EIn_copy multiD_2d = energyAngularModule.XYs2d( value=EIn.value * EInFactor, interpolation=EIn.interpolation) EpCls = EIn.copyDataToXYs() for e_out, Cls in EpCls: multiD_2d.append( energyAngularModule.Legendre([Cls], value=e_out)) energyAngularSubform.append(multiD_2d) form = energyAngularModule.form('', self.productFrame, energyAngularSubform) if (targetInfo.get("gammaToENDF6")): return (form) form.toENDF6(MT, endfMFList, flags, targetInfo) elif (isinstance(energySubform, energyModule.XYs2d) and isinstance(angularSubform, angularModule.XYs2d)): LANG, LEP = 12, 2 if (energySubform.interpolation == standardsModule.interpolation.flatToken): LEP = 1 # interpolation for E_out LANG = 11 elif (energySubform.interpolation in (standardsModule.interpolation.loglinToken, standardsModule.interpolation.loglogToken)): LANG = 14 MF6 = [ endfFormatsModule.endfContLine(0, 0, LANG, LEP, 1, len(energySubform)) ] EInInterpolation = gndToENDF6Module.gndToENDFInterpolationFlag( energySubform.interpolation) MF6 += endfFormatsModule.endfInterpolationList( [len(energySubform), EInInterpolation]) for indexE, EEpP in enumerate(energySubform): EMuP = angularSubform[indexE] if (EEpP.value != EMuP.value): raise Exception("EEpP.value = %s != EMuP.value = %s" % (EEpP.value, EMuP.value)) NA, NEP = 2 * len(EMuP), len(EEpP) MF6.append( endfFormatsModule.endfContLine(0, EEpP.value, 0, NA, NEP * (NA + 2), NEP)) data = [] for EpP in EEpP: data = [EpP[0], EpP[1]] for muP in EMuP: data += muP MF6 += endfFormatsModule.endfDataList(data) LAW = 1 gndToENDF6Module.toENDF6_MF6(MT, endfMFList, flags, targetInfo, LAW, frame, MF6) else: raise Exception( 'uncorrelated.toENDF6 not supported for energy subform = %s and angular subform = %s' % (energySubform.moniker, angularSubform.moniker)) else: # original data is in uncorrelated form if (MT not in [527, 528]): angularForm = angularModule.form("", frame, self.angularSubform.data) angularForm.toENDF6(MT, endfMFList, flags, targetInfo) energyForm = energyModule.form("", frame, self.energySubform.data) energyForm.toENDF6(MT, endfMFList, flags, targetInfo) if (MT == 527): endfMFList[26][MT][0]