def produce_electron_pair(S123): """A function to produce an electron and positron in opposite directions.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE * __cE)) ##Define beams to be along z: works well for Pythia 8.2. __E = math.sqrt(S123) / 2.0 __pV1 = fourVectors.fourVector(__E, 0.0, 0.0, __E) __pV2 = fourVectors.fourVector(__E, 0.0, 0.0, -__E) __eCode = particleData.knownParticles.get_code_from_name("electron") __p1 = particles.particle(__eCode, __pV1, [0, 0], [3, 4], [0, 0], -1) __p2 = particles.particle(-__eCode, __pV2, [0, 0], [3, 4], [0, 0], -1) __p1.set_unique_ID(1) __p2.set_unique_ID(2) return [__p1, __p2]
def produce_electron_pair(S123): """A function to produce an electron and positron in opposite directions.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE*__cE)) ##Define beams to be along z: works well for Pythia 8.2. __E = math.sqrt(S123)/2.0 __pV1 = fourVectors.fourVector(__E,0.0,0.0,__E) __pV2 = fourVectors.fourVector(__E,0.0,0.0,-__E) __eCode = particleData.knownParticles.get_code_from_name("electron") __p1 = particles.particle(__eCode,__pV1,[0,0],[3,4],[0,0],-1) __p2 = particles.particle(-__eCode,__pV2,[0,0],[3,4],[0,0],-1) __p1.set_unique_ID(1) __p2.set_unique_ID(2) return [__p1,__p2]
def calculate_split_ps(S123, Pperp, y): """A function to calculate the new p1,p2,p3 four-vectors following a dipole splitting.""" ##Letting p2 take +Pperp and p1 take -Pperp by convention. assert assertions.all_are_numbers([S123, Pperp, y]) assert ((S123 > 0.0) and (Pperp > 0.0)) __E1, __E2 = calculate_E1(S123, Pperp, y), calculate_E2(S123, Pperp, y) __E3, __kPerp = calculate_E3(S123, Pperp, y), calculate_kPerp(S123, Pperp, y) ##Store all energies produced for plotting graphs after showering: e1s.store(__E1) e2s.store(__E2) e3s.store(__E3) __randomPhi, __newP1 = get_random_phi(), fourVectors.fourVector( 0.0, 0.0, 0.0, 0.0) __newP2, __newP3 = fourVectors.fourVector(0.0, 0.0, 0.0, 0.0), fourVectors.fourVector( 0.0, 0.0, 0.0, 0.0) assert (0.0 < __randomPhi and __randomPhi < 2.0 * math.pi) ##Populate the first vector: __newP1[0] = __E1 __newP1[1] = (-1.0) * __kPerp * math.cos(__randomPhi) __newP1[2] = (-1.0) * __kPerp * math.sin(__randomPhi) __newP1[3] = math.sqrt((__E1 * __E1) - (__kPerp * __kPerp)) assert ((__newP1[0] > 0.0) and (__newP1[3] > 0.0)) ##Populate the second vector: __newP2[0] = __E2 __newP2[1] = __kPerp * math.cos(__randomPhi) __newP2[2] = __kPerp * math.sin(__randomPhi) __newP2[3] = math.sqrt((__E2 * __E2) - (__kPerp * __kPerp)) assert (__newP2[0] > 0.0) ##Populate the third vector. Entries 1 & 2 already 0 as required: __newP3[0] = __E3 __newP3[3] = (-1.0) * __E3 assert ((__newP3[0] > 0.0) and (__newP3[3] < 0.0)) ##Log x's for a produced particle for plotting after showering: tX1s.store(calculate_x1(S123, Pperp, y)) tX3s.store(calculate_x3(S123, Pperp, y)) ##Check the direction of the produced particle is consistent with parallel momentum conservation. ##This allows for different recoil configurations. if precision.check_numbers_equal(0.0, __newP1[3] + __newP2[3] + __newP3[3]): return __newP1, __newP2, __newP3 elif precision.check_numbers_equal(0.0, __newP1[3] - __newP2[3] + __newP3[3]): __newP2[3] = -__newP2[3] return __newP1, __newP2, __newP3 elif precision.check_numbers_equal(0.0, -__newP1[3] + __newP2[3] + __newP3[3]): __newP1[3] = -__newP1[3] return __newP1, __newP2, __newP3
def __init__(self,lookUpCodeOrName,fourMomentum = fourVectors.fourVector(),mothers = [0,0],children = [0,0],colours = [0,0], statusCode = 1): """A function to initiate a particle.""" ##Allow initiation via name or code but then works from the code. ##StatusCode: -1 initial, 0 = intermediate, 1 = final state. 1 chosen by default as this is currently a final state shower. assert ((type(lookUpCodeOrName) == int) or (type(lookUpCodeOrName) == str)) assert fourVectors.check_is_fourVector(fourMomentum) assert ((type(mothers) == list) and (type(mothers[0]) == int) and (type(mothers[1]) == int)) assert ((type(children) == list) and (type(children[0]) == int) and (type(children[1]) == int)) assert ((type(colours) == list) and (type(colours[0]) == int) and (type(colours[1]) == int)) assert (type(statusCode) == int) assert assertions.valid_particle_status_code(statusCode) if (type(lookUpCodeOrName) == int): assert particleData.knownParticles.has_key(lookUpCodeOrName) self.__lookUpCode = lookUpCodeOrName elif (type(lookUpCodeOrName) == str): assert particleData.knownParticles.has_name(lookUpCodeOrName) self.__lookUpCode = particleData.knownParticles.get_code_from_name(lookUpCodeOrName) self.__fourMomentum = fourMomentum self.__mothers = mothers self.__children = children self.__colours = colours self.__statusCode = statusCode self.__historyList = [False,False,False,False] ##Mothers then children (if set) self.__colourSetList = [False, False] for __i, __a in enumerate(self.__mothers+self.__children): ##Do both at once. if __a != 0: self.__historyList[__i] = True for __i, __a in enumerate(self.__colours): if __a != 0: self.__colourSetList[__i]= True self.__uniqueID = 0 self.__producedAt = -1 ##Default value for not set, as 0 is actually used.
def Sijk(listOfMomentumFourVectors): """A function to calculate the invariant quantity Sijk for Pi's in the given list.""" assert type(listOfMomentumFourVectors) == list __sqrtSijk = fourVectors.fourVector(0.0, 0.0, 0.0, 0.0) for __Pi in listOfMomentumFourVectors: assert fourVectors.check_is_fourVector(__Pi) assert __Pi.__nonzero__() __sqrtSijk += __Pi __Sikj = __sqrtSijk * __sqrtSijk return __Sikj
def get_event_particle_four_momentum(self,eventIndex,particleIndex): """A function to get the four-momentum of a particle in an event in an LHEF XML file.""" assert ((type(eventIndex) == int) and (type(particleIndex) == int)) __fourVector = fourVectors.fourVector() ##Energy is the last component in the LHEF __fourVector[0] = float(self.get_event_particle_strings(eventIndex,particleIndex)[9]) __fourVector[1] = float(self.get_event_particle_strings(eventIndex,particleIndex)[6]) __fourVector[2] = float(self.get_event_particle_strings(eventIndex,particleIndex)[7]) __fourVector[3] = float(self.get_event_particle_strings(eventIndex,particleIndex)[8]) return __fourVector
def produce_quark_directions(S123, theta): """A function to produce a set of opposite directional quark vectors in opposite directions.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE * __cE)) assert ((type(theta) == float) and (0.0 <= theta) and (theta <= math.pi)) __phi = kinematics.get_random_phi() __x = math.sin(theta) * math.cos(__phi) __y = math.sin(theta) * math.sin(__phi) __z = math.cos(theta) __direction = fourVectors.fourVector(0.0, __x, __y, __z) __oppositeDirection = __direction.copy() __oppositeDirection *= -1.0 return __direction, __oppositeDirection
def produce_quark_directions(S123,theta): """A function to produce a set of opposite directional quark vectors in opposite directions.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE*__cE)) assert((type(theta) == float) and (0.0 <= theta) and (theta <= math.pi)) __phi = kinematics.get_random_phi() __x = math.sin(theta)*math.cos(__phi) __y = math.sin(theta)*math.sin(__phi) __z = math.cos(theta) __direction = fourVectors.fourVector(0.0,__x,__y,__z) __oppositeDirection = __direction.copy() __oppositeDirection *= -1.0 return __direction, __oppositeDirection
def get_event_particle_four_momentum(self, eventIndex, particleIndex): """A function to get the four-momentum of a particle in an event in an LHEF XML file.""" assert ((type(eventIndex) == int) and (type(particleIndex) == int)) __fourVector = fourVectors.fourVector() ##Energy is the last component in the LHEF __fourVector[0] = float( self.get_event_particle_strings(eventIndex, particleIndex)[9]) __fourVector[1] = float( self.get_event_particle_strings(eventIndex, particleIndex)[6]) __fourVector[2] = float( self.get_event_particle_strings(eventIndex, particleIndex)[7]) __fourVector[3] = float( self.get_event_particle_strings(eventIndex, particleIndex)[8]) return __fourVector
def inverse_boost(self,pVIn): """A function to perform the inverse lorentz boost on a given (E,p) four-vector.""" assert fourVectors.check_is_fourVector(pVIn) assert pVIn.__nonzero__() ##Make sure it's not space-like: assert (check_timelike(pVIn) or check_lightlike(pVIn)) __pVOut = fourVectors.fourVector() __energyOut = (self.__reverseMomentumOfCMF * pVIn)/self.__massOfCMF __alpha = (pVIn[0]+__energyOut)/(self.__massOfCMF + self.__momentumOfCMF[0]) __pVOut[0] = __energyOut for __i3 in range(3): __pVOut[__i3+1] = pVIn[__i3+1] - __alpha * self.__reverseMomentumOfCMF[__i3+1] ##Make sure its still not space-like after the boost: assert (check_timelike(__pVOut) or check_lightlike(__pVOut)) return __pVOut
def inverse_boost(self, pVIn): """A function to perform the inverse lorentz boost on a given (E,p) four-vector.""" assert fourVectors.check_is_fourVector(pVIn) assert pVIn.__nonzero__() ##Make sure it's not space-like: assert (check_timelike(pVIn) or check_lightlike(pVIn)) __pVOut = fourVectors.fourVector() __energyOut = (self.__reverseMomentumOfCMF * pVIn) / self.__massOfCMF __alpha = (pVIn[0] + __energyOut) / (self.__massOfCMF + self.__momentumOfCMF[0]) __pVOut[0] = __energyOut for __i3 in range(3): __pVOut[__i3 + 1] = pVIn[ __i3 + 1] - __alpha * self.__reverseMomentumOfCMF[__i3 + 1] ##Make sure its still not space-like after the boost: assert (check_timelike(__pVOut) or check_lightlike(__pVOut)) return __pVOut
def boost(self,pVIn): """A function to perform the lorentz boost on a given (E,p) four-vector.""" assert fourVectors.check_is_fourVector(pVIn) assert pVIn.__nonzero__() ##Make sure it's not space-like: __pVIn = pVIn.copy() assert (check_timelike(__pVIn) or check_lightlike(__pVIn)) ##Make sure not trying to boost into its own CMF: if check_lightlike(__pVIn): assert (__pVIn != self.__momentumOfCMF) __pVOut = fourVectors.fourVector() __energyPrime = (self.__momentumOfCMF * __pVIn)/self.__massOfCMF __alpha = (__pVIn[0]+__energyPrime)/(self.__massOfCMF + self.__momentumOfCMF[0]) __pVOut[0] = __energyPrime for __i2 in range(3): __pVOut[__i2+1] = __pVIn[__i2+1] - __alpha * self.__momentumOfCMF[__i2+1] ##Make sure its still not space-like after the boost: assert (check_timelike(__pVOut) or check_lightlike(__pVOut)) return __pVOut
def boost(self, pVIn): """A function to perform the lorentz boost on a given (E,p) four-vector.""" assert fourVectors.check_is_fourVector(pVIn) assert pVIn.__nonzero__() ##Make sure it's not space-like: __pVIn = pVIn.copy() assert (check_timelike(__pVIn) or check_lightlike(__pVIn)) ##Make sure not trying to boost into its own CMF: if check_lightlike(__pVIn): assert (__pVIn != self.__momentumOfCMF) __pVOut = fourVectors.fourVector() __energyPrime = (self.__momentumOfCMF * __pVIn) / self.__massOfCMF __alpha = (__pVIn[0] + __energyPrime) / (self.__massOfCMF + self.__momentumOfCMF[0]) __pVOut[0] = __energyPrime for __i2 in range(3): __pVOut[__i2 + 1] = __pVIn[__i2 + 1] - __alpha * self.__momentumOfCMF[__i2 + 1] ##Make sure its still not space-like after the boost: assert (check_timelike(__pVOut) or check_lightlike(__pVOut)) return __pVOut
##Module test code:## if __name__ == "__main__": ##Import modules required for testing:## import random ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////" print "Testing lorentz module:" print "///////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." tLightlike = fourVectors.fourVector(math.sqrt(3*3 + 4*4 + 5*5),3,4,5) tMomentum4V1 = fourVectors.fourVector(200,30,50,40) tMomentum4V2 = fourVectors.fourVector(215,66,12,52) tNotTooFast1 = 0.87 tNotTooFast2 = 1.0 tTooFast1 = 1.01 tTooFast2 = 109 tBoost1 = lorentzBoost(tMomentum4V1) tFourVectors = {'a':None,'b':None,'c':None,'d':None} tMomentumSquares = {'a':None,'b':None,'c':None,'d':None} tBoostedMomentumSquares = {'a':None,'b':None,'c':None,'d':None} tSumMomentums = fourVectors.fourVector(0,0,0,0) tBoostedSumMomentums = fourVectors.fourVector(0,0,0,0) ##Generate random test four-vectors:## for tFourVector in tFourVectors: tX0 = random.randrange(1000,2000)/10.0
##Test all get_event_particle_'' functions:## print "\n--------------------------------------------------\n" print "Testing all get_event_particle_'' functions:\n" print "Using the first event in '" + testPathIn + "':" print "\nThe PDGID is:", testReader.get_event_particle_ID(0,0) print "The 'when' code is:", testReader.get_event_particle_when(0,0) print "The mothers are:", testReader.get_event_particle_mothers(0,0) print "The coloursL are:", testReader.get_event_particle_colours(0,0) print "The four-momentum is:", testReader.get_event_particle_four_momentum(0,0) print "The mass is:", testReader.get_event_particle_mass(0,0) print "The proper lifetime is:", testReader.get_event_particle_lifetime(0,0) print "The spin is:", testReader.get_event_particle_spin(0,0) results = [testReader.get_event_particle_ID(0,0),testReader.get_event_particle_when(0,0),testReader.get_event_particle_mothers(0,0)] results += [testReader.get_event_particle_colours(0,0),testReader.get_event_particle_four_momentum(0,0),testReader.get_event_particle_mass(0,0)] results += [testReader.get_event_particle_lifetime(0,0),testReader.gget_event_particle_spin(0,0)] expected = [11,-1,0,0,0,0,fourVectors.fourVector(5.2899734145e+00,0.0000000000e+00,0.0000000000e+00,5.2899734145e+00),0,0,9] if (results == expected): print "Test successful!" else: print "Test failed!" print "\nFinished testing all get_event_particle_'' functions." assertions.pause(__name__) ##Test LHEFShowerWriter class:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////////////" print "Testing LHEFShowerWriter class:" print "///////////////////////////////" assertions.pause(__name__)
print "Testing counters module:" print "////////////////////////" assertions.pause(__name__) ##Setup here:## tCounter1 = counter(0) tCounter2 = counter(501) tCounter3 = counter(0) tCounter4 = counter(501) tNumIts = 1000000 ##Test check_is_counter:## print "\n--------------------------------------------------\n" print "Testing check_is_counter:" print "Calling check_is_counter on instance: " , check_is_counter(tCounter1) print "Calling check_is_counter on wrong instance: " , check_is_counter(fourVectors.fourVector()) print "Calling check_is_counter on 1.055: " , check_is_counter(1.055) print "Calling check_is_counter on 'word': " , check_is_counter('word') tResults = [check_is_counter(tCounter1),check_is_counter(fourVectors.fourVector())] tResults += [check_is_counter(1.055),check_is_counter('word')] if (sum(tResults) == 1): print "\nTest successful!" else: print "\nTest failed!" print "\nFinished testing check_is_counter." assertions.pause(__name__) ##Test counter class:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "//////////////////////"
def get_momentum_in_CMF(self): """A function to return the four-vector in its COM frame.""" return fourVectors.fourVector(self.__massOfCMF, 0.0, 0.0, 0.0)
testReader.get_event_particle_ID(0, 0), testReader.get_event_particle_when(0, 0), testReader.get_event_particle_mothers(0, 0) ] results += [ testReader.get_event_particle_colours(0, 0), testReader.get_event_particle_four_momentum(0, 0), testReader.get_event_particle_mass(0, 0) ] results += [ testReader.get_event_particle_lifetime(0, 0), testReader.gget_event_particle_spin(0, 0) ] expected = [ 11, -1, 0, 0, 0, 0, fourVectors.fourVector(5.2899734145e+00, 0.0000000000e+00, 0.0000000000e+00, 5.2899734145e+00), 0, 0, 9 ] if (results == expected): print "Test successful!" else: print "Test failed!" print "\nFinished testing all get_event_particle_'' functions." assertions.pause(__name__) ##Test LHEFShowerWriter class:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////////////" print "Testing LHEFShowerWriter class:" print "///////////////////////////////" assertions.pause(__name__)
##Module test code:## if __name__ == "__main__": ##Import modules required for testing:## import random ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////" print "Testing lorentz module:" print "///////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." tLightlike = fourVectors.fourVector(math.sqrt(3 * 3 + 4 * 4 + 5 * 5), 3, 4, 5) tMomentum4V1 = fourVectors.fourVector(200, 30, 50, 40) tMomentum4V2 = fourVectors.fourVector(215, 66, 12, 52) tNotTooFast1 = 0.87 tNotTooFast2 = 1.0 tTooFast1 = 1.01 tTooFast2 = 109 tBoost1 = lorentzBoost(tMomentum4V1) tFourVectors = {'a': None, 'b': None, 'c': None, 'd': None} tMomentumSquares = {'a': None, 'b': None, 'c': None, 'd': None} tBoostedMomentumSquares = {'a': None, 'b': None, 'c': None, 'd': None} tSumMomentums = fourVectors.fourVector(0, 0, 0, 0) tBoostedSumMomentums = fourVectors.fourVector(0, 0, 0, 0) ##Generate random test four-vectors:## for tFourVector in tFourVectors: tX0 = random.randrange(1000, 2000) / 10.0
import math ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "//////////////////////" print "Testing chains module:" print "//////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## testFourVectors = {'a':None,'b':None,'c':None,'d':None,'e':None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector1, testVector2 = fourVectors.fourVector(0,0,0,0), fourVectors.fourVector(0,0,0,0) ##Required to start while loop. selectionFinished = False while (not selectionFinished): for testFourVector in testFourVectors: x1 = random.randrange(1,100) x2 = random.randrange(0,100) x3 = random.randrange(0,100) ##Make them massless. x0 = math.sqrt((x1*x1) + (x2*x2) +(x3*x3)) testFourVectors[testFourVector] = fourVectors.fourVector(x0,x1,x2,x3) testVector1 = testFourVectors['a'].copy() testVector2 = testFourVectors['b'].copy() testVector3 = testFourVectors['c'].copy() testVector4 = testFourVectors['d'].copy() testVector5 = testFourVectors['e'].copy() ##Want five independent energy-momentum four-vectors.
print "////////////////////////" assertions.pause(__name__) ##Setup here:## tCounter1 = counter(0) tCounter2 = counter(501) tCounter3 = counter(0) tCounter4 = counter(501) tNumIts = 1000000 ##Test check_is_counter:## print "\n--------------------------------------------------\n" print "Testing check_is_counter:" print "Calling check_is_counter on instance: ", check_is_counter(tCounter1) print "Calling check_is_counter on wrong instance: ", check_is_counter( fourVectors.fourVector()) print "Calling check_is_counter on 1.055: ", check_is_counter(1.055) print "Calling check_is_counter on 'word': ", check_is_counter('word') tResults = [ check_is_counter(tCounter1), check_is_counter(fourVectors.fourVector()) ] tResults += [check_is_counter(1.055), check_is_counter('word')] if (sum(tResults) == 1): print "\nTest successful!" else: print "\nTest failed!" print "\nFinished testing check_is_counter." assertions.pause(__name__) ##Test counter class:##
##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "//////////////////////////" print "Testing kinematics module:" print "//////////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." tS123 = 0.0 ##Needed to start while loop. while tS123 < 10.0: ##Generate random test four-vectors: tFourVectors = {'a': None, 'b': None, 'c': None, 'd': None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. tVector1, tVector2 = fourVectors.fourVector(0, 0, 0, 0), fourVectors.fourVector( 0, 0, 0, 0) while ( (tVector1 == tVector2) or (not fourVectors.check_different_direction(tVector1, tVector2))): for tFourVector in tFourVectors: ##Random range set so as to produce a vector slower than the speed of light. tX1 = random.randrange(2, 100) tX2 = random.randrange(2, 100) tX3 = random.randrange(2, 100) ##Make them massless. tX0 = math.sqrt((tX1 * tX1) + (tX2 * tX2) + (tX3 * tX3)) tFourVectors[tFourVector] = fourVectors.fourVector( tX0, tX1, tX2, tX3) tExpectedSab = tFourVectors['a'] * tFourVectors[ 'a'] + tFourVectors['b'] * tFourVectors['b']
import fourVectors ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////" print "Testing dipoles module:" print "///////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## testFourVectors1 = {'a':None,'b':None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector1, testVector2 = fourVectors.fourVector(0,0,0,0), fourVectors.fourVector(0,0,0,0) ##Required to start while loop. while ((testVector1 == testVector2) or (not fourVectors.check_different_direction(testVector1,testVector2))): for testFourVector in testFourVectors1: x1 = random.randrange(1,10)/10.0 x2 = random.randrange(0,int(math.sqrt(1-(x1**2))*10))/10.0 x3 = random.randrange(0,int(math.sqrt(1-(x2**2))*10))/10.0 ##Make them massless. x0 = math.sqrt((x1*x1) + (x2*x2) +(x3*x3)) testFourVectors1[testFourVector] = fourVectors.fourVector(x0,x1,x2,x3) testVector1 = testFourVectors1['a'].copy() testVector2 = testFourVectors1['b'].copy() ##Generate set 2: testFourVectors2 = {'a':None,'b':None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector3, testVector4 = fourVectors.fourVector(0,0,0,0), fourVectors.fourVector(0,0,0,0) ##Required to start while loop. while ((testVector3 == testVector4) or (not fourVectors.check_different_direction(testVector3,testVector4))):
print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////////" print "Testing dataLoggers module:" print "///////////////////////////" assertions.pause(__name__) ##Setup here:## tLogger1 = dataLogger() tNumIts = 1000000 ##Test check_is_dataLogger:## print "\n--------------------------------------------------\n" print "Testing check_is_dataLogger:" print "Calling check_is_dataLogger on instance: " , check_is_dataLogger(tLogger1) print "Calling check_is_dataLogger on wrong instance: " , check_is_dataLogger(fourVectors.fourVector()) print "Calling check_is_dataLogger on 1.055: " , check_is_dataLogger(1.055) print "Calling check_is_dataLogger on 'word': " , check_is_dataLogger('word') tResults = [check_is_dataLogger(tLogger1),check_is_dataLogger(fourVectors.fourVector())] tResults += [check_is_dataLogger(1.055),check_is_dataLogger('word')] if (sum(tResults) == 1): print "\nTest successful!" else: print "\nTest failed!" print "\nFinished testing check_is_dataLogger." assertions.pause(__name__) ##Test dataLogger class:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "/////////////////////////"
print "----------------------------------------------------------------------\n" print "////////////////////////" print "Testing particles module:" print "////////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## tFourVectors = {'a':None,'b':None,'c':None,'d':None} for tFourVector in tFourVectors: tX0 = random.randrange(20) tX1 = random.randrange(20) tX2 = random.randrange(20) tX3 = random.randrange(20) tFourVectors[tFourVector] = fourVectors.fourVector(tX0,tX1,tX2,tX3) tZeroParticle = particle(3) tParticle1 = particle(2,tFourVectors['a'].copy(),[5,6],[7,8],[51,52],-1) tParticle2 = particle(1,tFourVectors['b'].copy(),[0,0],[0,0],[0,0],-1) tParticle3 = particle('photon',tFourVectors['c'].copy()) tParticle4 = tZeroParticle.copy() tParticle4.set_four_momentum(tParticle1.get_four_momentum()) tP1C = tParticle1.copy() tParticle5 = particle(2,tFourVectors['a'].copy(),[5,6],[7,8],[51,52],-1) tQuark1 = particle(1,tFourVectors['a'].copy()) tQuark2FourVector = tFourVectors['a'].copy() tQuark2FourVector *= 2 tGluon2FourVector = tQuark2FourVector.copy() tQuark2 = particle(2,tQuark2FourVector) tGluon1 = particle(21,tFourVectors['a'].copy()) tGluon2 = particle(21,tGluon2FourVector)
import particles ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "/////////////////////////////////" print "Testing resultsContainers module:" print "/////////////////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## testFourVectors = {'a':None,'b':None,'c':None,'d':None,'e':None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector1, testVector2 = fourVectors.fourVector(0,0,0,0), fourVectors.fourVector(0,0,0,0) selectionFinished = False while (not selectionFinished): for testFourVector in testFourVectors: x1 = random.randrange(1,100) x2 = random.randrange(0,100) x3 = random.randrange(0,100) ##Make them massless. x0 = math.sqrt((x1*x1) + (x2*x2) +(x3*x3)) testFourVectors[testFourVector] = fourVectors.fourVector(x0,x1,x2,x3) testVector1 = testFourVectors['a'].copy() testVector2 = testFourVectors['b'].copy() testVector3 = testFourVectors['c'].copy() testVector4 = testFourVectors['d'].copy() testVector5 = testFourVectors['e'].copy() ##Want five independent energy-momentum four-vectors.
print "///////////////////////////" print "Testing dataLoggers module:" print "///////////////////////////" assertions.pause(__name__) ##Setup here:## tLogger1 = dataLogger() tNumIts = 1000000 ##Test check_is_dataLogger:## print "\n--------------------------------------------------\n" print "Testing check_is_dataLogger:" print "Calling check_is_dataLogger on instance: ", check_is_dataLogger( tLogger1) print "Calling check_is_dataLogger on wrong instance: ", check_is_dataLogger( fourVectors.fourVector()) print "Calling check_is_dataLogger on 1.055: ", check_is_dataLogger(1.055) print "Calling check_is_dataLogger on 'word': ", check_is_dataLogger( 'word') tResults = [ check_is_dataLogger(tLogger1), check_is_dataLogger(fourVectors.fourVector()) ] tResults += [check_is_dataLogger(1.055), check_is_dataLogger('word')] if (sum(tResults) == 1): print "\nTest successful!" else: print "\nTest failed!" print "\nFinished testing check_is_dataLogger." assertions.pause(__name__)
import fourVectors ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "///////////////////////" print "Testing dipoles module:" print "///////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## testFourVectors1 = {'a': None, 'b': None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector1, testVector2 = fourVectors.fourVector( 0, 0, 0, 0), fourVectors.fourVector(0, 0, 0, 0) ##Required to start while loop. while ( (testVector1 == testVector2) or (not fourVectors.check_different_direction(testVector1, testVector2))): for testFourVector in testFourVectors1: x1 = random.randrange(1, 10) / 10.0 x2 = random.randrange(0, int(math.sqrt(1 - (x1**2)) * 10)) / 10.0 x3 = random.randrange(0, int(math.sqrt(1 - (x2**2)) * 10)) / 10.0 ##Make them massless. x0 = math.sqrt((x1 * x1) + (x2 * x2) + (x3 * x3)) testFourVectors1[testFourVector] = fourVectors.fourVector( x0, x1, x2, x3) testVector1 = testFourVectors1['a'].copy() testVector2 = testFourVectors1['b'].copy() ##Generate set 2:
import particles ##Begin testing:## print "\n----------------------------------------------------------------------" print "----------------------------------------------------------------------\n" print "/////////////////////////////////" print "Testing resultsContainers module:" print "/////////////////////////////////" assertions.pause(__name__) ##Setup here:## print "\nGenerating test values..." ##Generate random test four-vectors:## testFourVectors = {'a': None, 'b': None, 'c': None, 'd': None, 'e': None} ##Prevent the random vectors being the same as can't boost into frame of massless particle. testVector1, testVector2 = fourVectors.fourVector( 0, 0, 0, 0), fourVectors.fourVector(0, 0, 0, 0) selectionFinished = False while (not selectionFinished): for testFourVector in testFourVectors: x1 = random.randrange(1, 100) x2 = random.randrange(0, 100) x3 = random.randrange(0, 100) ##Make them massless. x0 = math.sqrt((x1 * x1) + (x2 * x2) + (x3 * x3)) testFourVectors[testFourVector] = fourVectors.fourVector( x0, x1, x2, x3) testVector1 = testFourVectors['a'].copy() testVector2 = testFourVectors['b'].copy() testVector3 = testFourVectors['c'].copy() testVector4 = testFourVectors['d'].copy() testVector5 = testFourVectors['e'].copy()