def __init__(self,orderedListOfParticles,isLoop = False,maxPperpSquaredFromSplit = None): """A function to initialise a chain using the ordered list of particles given.""" ##Accepting an ordered list of particles allows the initialisation of a chain of any length at any stage. for particle in orderedListOfParticles: assert particles.check_is_particle(particle) assert (isLoop or not(isLoop)) assert ((maxPperpSquaredFromSplit == None) or (assertions.all_are_numbers([maxPperpSquaredFromSplit]))) self.__chainList = [] for i in range(len(orderedListOfParticles) - 1): ##Iterate through all particle pairs. self.__chainList.append(dipoles.dipole(orderedListOfParticles[i],orderedListOfParticles[i+1])) self.__isLoop = isLoop if (maxPperpSquaredFromSplit == None): if (len(self.__chainList) == 1): self.__maxPperpSquared = self.__chainList[0].get_mass_squared() else: print "\n! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !" print "Not sure what to do here yet!" #assert False self.__maxPperpSquared = self.__chainList[0].get_mass_squared() assertions.pause_loading_module() ##Or do you find that of the entire chain. Or do you find that of each -> Need list? else: self.__maxPperpSquared = maxPperpSquaredFromSplit self.__cutOff = constants.cut_off_energy()*constants.cut_off_energy() self.__nextPperpSquared = None ##Initiation value. self.__showeringCompleted = False
def __init__(self):
"""A function to initiate a one-loop fine structure constant."""
self.__oneLoopAlphaEMOfMzSquared = constants.one_loop_alphaEM_of_Mz_squared(
)
self.__showerCutOffEnergy = constants.cut_off_energy()
##Currently only set for showering on resonance with the Z-boson channel:
self.__alphaEMMax = self.__oneLoopAlphaEMOfMzSquared
def get_quark_weights(S123, posQuarkCodes, cosTheta=None):
"""A function to calculate the quark weights to beused by the ME generator."""
__cE = constants.cut_off_energy()
assert ((type(S123) == float) and (S123 > __cE * __cE))
assert (type(posQuarkCodes) == list)
assert (((type(cosTheta) == float) and (-1.0 <= cosTheta) and
(cosTheta <= 1.0)) or (cosTheta == None))
##Using dictionary not list so you don't have to assume an order of the quark codes.
__hardCodedQWeights = {
1: 16.05764282,
2: 11.94029851,
3: 16.05764282,
4: 24.32321153,
5: 31.62120432
}
__qWeights = {} ##Empty dictionary initiated.
for __qCode in posQuarkCodes: ##Uses the quark codes given to weight for the chosen set.
if (cosTheta == None):
__qWeights[__qCode] = __hardCodedQWeights[
__qCode] ##Only take the hard coded ones required so normalisation works.
else:
__qWeights[__qCode] = calc_f_for_cos_theta(S123, __qCode, cosTheta)
__total = sum(__qWeights.itervalues())
__qWeights.update(
(x, y / __total) for x, y in __qWeights.items()) ##Normalise them
assert precision.check_numbers_equal(
sum(__qWeights.itervalues()),
1.0) ##i.e they should now be normalised to 1.
return __qWeights
def __init__(self):
"""A function to initiate a one-loop strong coupling constant."""
self.__oneLoopAlphaSOfMzSquared = constants.one_loop_alphaS_of_Mz_squared(
)
self.__showerCutOffEnergy = constants.cut_off_energy()
self.__alphaSMax = self.calculate(self.__showerCutOffEnergy *
self.__showerCutOffEnergy)
def get_code_and_theta(S123, posQuarkCodes):
"""A function to select a quark code and cos(theta) value consistent with the differential cross section."""
__cE = constants.cut_off_energy()
assert ((type(S123) == float) and (S123 > __cE * __cE))
assert (type(posQuarkCodes) == list)
__qCode = get_quark_code(S123, posQuarkCodes)
__theta = get_quarks_theta(S123, __qCode)
return __qCode, __theta
def get_code_and_theta(S123,posQuarkCodes): """A function to select a quark code and cos(theta) value consistent with the differential cross section.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE*__cE)) assert (type(posQuarkCodes) == list) __qCode = get_quark_code(S123,posQuarkCodes) __theta = get_quarks_theta(S123,__qCode) return __qCode, __theta
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 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 get_quark_code(S123,posQuarkCodes,cosTheta = None): """A function to return a weighted random quark code.""" __cE = constants.cut_off_energy() assert ((type(S123) == float) and (S123 > __cE*__cE)) assert (type(posQuarkCodes) == list) assert (((type(cosTheta) == float) and (-1.0 <= cosTheta) and (cosTheta <= 1.0)) or (cosTheta == None)) __qWeights = get_quark_weights(S123,posQuarkCodes,cosTheta) ##Re-set for every cosTheta. __R = random.random() ##Doesn't include 1 so using < not <= for checks is fair. __sumSoFar = 0.0 for __qCode in posQuarkCodes: ##Using the initialised set for which the weights are normalised to 1. __sumSoFar += __qWeights[__qCode] if (__R < __sumSoFar): return __qCode assert False ##Should have returned by now!
def scaled_quark_directions(S123,theta): """A function to return two quark directional vectors scaled to match a given S123 value.""" __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)) __E = math.sqrt(S123)/2.0 __dV1, __dV2 = produce_quark_directions(S123,theta) __magnitude = __dV1.calculate_cartesian_magnitude() __scale = __E/__magnitude __dV1 *= __scale __dV2 *= __scale __dV1[0], __dV2[0] = __E, __E ##Check massless: assert (precision.check_numbers_equal(__dV1*__dV1,0.0) and precision.check_numbers_equal(__dV2*__dV2,0.0)) return __dV1, __dV2
def scaled_quark_directions(S123, theta):
"""A function to return two quark directional vectors scaled to match a given S123 value."""
__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))
__E = math.sqrt(S123) / 2.0
__dV1, __dV2 = produce_quark_directions(S123, theta)
__magnitude = __dV1.calculate_cartesian_magnitude()
__scale = __E / __magnitude
__dV1 *= __scale
__dV2 *= __scale
__dV1[0], __dV2[0] = __E, __E
##Check massless:
assert (precision.check_numbers_equal(__dV1 * __dV1, 0.0)
and precision.check_numbers_equal(__dV2 * __dV2, 0.0))
return __dV1, __dV2
def get_quark_code(S123, posQuarkCodes, cosTheta=None):
"""A function to return a weighted random quark code."""
__cE = constants.cut_off_energy()
assert ((type(S123) == float) and (S123 > __cE * __cE))
assert (type(posQuarkCodes) == list)
assert (((type(cosTheta) == float) and (-1.0 <= cosTheta) and
(cosTheta <= 1.0)) or (cosTheta == None))
__qWeights = get_quark_weights(S123, posQuarkCodes,
cosTheta) ##Re-set for every cosTheta.
__R = random.random(
) ##Doesn't include 1 so using < not <= for checks is fair.
__sumSoFar = 0.0
for __qCode in posQuarkCodes: ##Using the initialised set for which the weights are normalised to 1.
__sumSoFar += __qWeights[__qCode]
if (__R < __sumSoFar):
return __qCode
assert False ##Should have returned by now!
def get_quark_weights(S123,posQuarkCodes,cosTheta = None):
"""A function to calculate the quark weights to beused by the ME generator."""
__cE = constants.cut_off_energy()
assert ((type(S123) == float) and (S123 > __cE*__cE))
assert (type(posQuarkCodes) == list)
assert (((type(cosTheta) == float) and (-1.0 <= cosTheta) and (cosTheta <= 1.0)) or (cosTheta == None))
##Using dictionary not list so you don't have to assume an order of the quark codes.
__hardCodedQWeights = {1:16.05764282,2:11.94029851,3:16.05764282,4:24.32321153,5:31.62120432}
__qWeights = {} ##Empty dictionary initiated.
for __qCode in posQuarkCodes: ##Uses the quark codes given to weight for the chosen set.
if (cosTheta == None):
__qWeights[__qCode] = __hardCodedQWeights[__qCode] ##Only take the hard coded ones required so normalisation works.
else:
__qWeights[__qCode] = calc_f_for_cos_theta(S123,__qCode,cosTheta)
__total = sum(__qWeights.itervalues())
__qWeights.update((x, y/__total) for x, y in __qWeights.items()) ##Normalise them
assert precision.check_numbers_equal(sum(__qWeights.itervalues()),1.0) ##i.e they should now be normalised to 1.
return __qWeights
def produce_quark_pair(S123,posQuarkCodes): """A function to produce a particle and anti-particle in opposite directions.""" __cE = constants.cut_off_energy() __knownQuarks = particleData.knownParticles.get_known_quarks() assert ((type(S123) == float) and (S123 > __cE*__cE)) assert (type(posQuarkCodes) == list) for code in posQuarkCodes: assert (type(code) == int) assert (code in __knownQuarks) __qCode, __qTheta = quarkPairs.get_code_and_theta(S123,posQuarkCodes) quarkCounters[__qCode - 1].count() ##-1 for list index. createdThetas.store(__qTheta) createdQuarkCodes.store(__qCode) __pV1, __pV2 = scaled_quark_directions(S123,__qTheta) __p1 = particles.particle(__qCode,__pV1,[1,2],[0,0],[501,0],1) __p2 = particles.particle(-__qCode,__pV2,[1,2],[0,0],[0,501],1) __p1.set_unique_ID(3) __p2.set_unique_ID(4) __p1.set_produced_at(S123) __p2.set_produced_at(S123) return [__p1,__p2]
def produce_quark_pair(S123, posQuarkCodes):
"""A function to produce a particle and anti-particle in opposite directions."""
__cE = constants.cut_off_energy()
__knownQuarks = particleData.knownParticles.get_known_quarks()
assert ((type(S123) == float) and (S123 > __cE * __cE))
assert (type(posQuarkCodes) == list)
for code in posQuarkCodes:
assert (type(code) == int)
assert (code in __knownQuarks)
__qCode, __qTheta = quarkPairs.get_code_and_theta(S123, posQuarkCodes)
quarkCounters[__qCode - 1].count() ##-1 for list index.
createdThetas.store(__qTheta)
createdQuarkCodes.store(__qCode)
__pV1, __pV2 = scaled_quark_directions(S123, __qTheta)
__p1 = particles.particle(__qCode, __pV1, [1, 2], [0, 0], [501, 0], 1)
__p2 = particles.particle(-__qCode, __pV2, [1, 2], [0, 0], [0, 501], 1)
__p1.set_unique_ID(3)
__p2.set_unique_ID(4)
__p1.set_produced_at(S123)
__p2.set_produced_at(S123)
return [__p1, __p2]
##Begin testing:##
print "\n----------------------------------------------------------------------"
print "----------------------------------------------------------------------\n"
print "////////////////////////////////"
print "Testing runningCouplings module:"
print "////////////////////////////////"
assertions.pause(__name__)
##Setup here:##
print "\nGenerating test values..."
tOneLoopAlphaS = oneLoopAlphaS()
tOneLoopAlphaEM = oneLoopAlphaEM()
tTwoLoopAlphaS = twoLoopAlphaS()
tFourLoopAlphaS = fourLoopAlphaS()
tCutOffEnergy = constants.cut_off_energy()
tQRange = range(2,3700,1)
tNfQRange = range(0,3700000,100)
tNfs , tOneLoopAlphaSs, tTwoLoopAlphaSs = [], [], []
tOneLoopAlphaEMs = []
tFourLoopAlphaSs, tDifferenceInAlphaSs = [], []
tOneLoopWeightedAlphaSs, tTwoLoopWeightedAlphaSs, tFourLoopWeightedAlphaSs = [], [], []
tOneLoopWeightedAlphaEMs = []
tBeta0s, tLns, tDenoms = [] , [], []
tZBosonMass = particleData.knownParticles.get_mass_from_code(particleData.knownParticles.get_code_from_name('Z-boson'))
tZBosonMassSquared = tZBosonMass * tZBosonMass
for tN1, tX1 in enumerate(tQRange):
tQRange[tN1] = (tQRange[tN1]/10.0)
tOneLoopAlphaSs.append(tOneLoopAlphaS.calculate(tQRange[tN1]**2))
tOneLoopAlphaEMs.append(tOneLoopAlphaEM.calculate(tQRange[tN1]**2))
tTwoLoopAlphaSs.append(tTwoLoopAlphaS.calculate(tQRange[tN1]))
def __init__(self): """A function to initiate a one-loop strong coupling constant.""" self.__oneLoopAlphaSOfMzSquared = constants.one_loop_alphaS_of_Mz_squared() self.__showerCutOffEnergy = constants.cut_off_energy() self.__alphaSMax = self.calculate(self.__showerCutOffEnergy*self.__showerCutOffEnergy)
def __init__(self): """A function to initiate a one-loop fine structure constant.""" self.__oneLoopAlphaEMOfMzSquared = constants.one_loop_alphaEM_of_Mz_squared() self.__showerCutOffEnergy = constants.cut_off_energy() ##Currently only set for showering on resonance with the Z-boson channel: self.__alphaEMMax = self.__oneLoopAlphaEMOfMzSquared
def solve_sudakovs(PperpSquaredMax,
S123,
difCrossSecIds,
code1,
code2,
logCrosSecs=None):
"""A function to generate a PperpSquared and y for an emission or splitting, using the Sudakov form factor."""
##Codes 1,2 still needed to get the charges for EM radiation.
##Using veto algorithm in "PYTHIA 6.0 Physics and Manual".
##And p198 of "Monte Carlo simulations of hard QCD radiation" for bivariant algorithm.
##And p16 of "Initial-state showering based on colour dipoles connected to incoming parton lines" for real y limits.
##And p5 of "Fooling around with the Sudakov veto algorithm" for multiple emission form.
assert assertions.all_are_numbers([PperpSquaredMax, S123])
assert (type(difCrossSecIds) == list)
__kQs = particleData.knownParticles.get_known_quarks()
__gC = particleData.knownParticles.get_code_from_name('gluon')
__expectedCodes = __kQs + [-x for x in __kQs] + [__gC]
assert ((code1 in __expectedCodes) and (code2 in __expectedCodes))
__cutOff = constants.cut_off_energy() * constants.cut_off_energy()
if (PperpSquaredMax < __cutOff):
return None, None, None
__notChosen1, __y, __PperpSquaredi = True, 0, assertions.force_float_number(
PperpSquaredMax)
__PperpSquarediMinus1 = __PperpSquaredi
while __notChosen1: ##i += 1
__notChosen2 = True
while __notChosen2:
__R1 = random.random()
__PperpSquaredi = calc_inv_G(
(math.log(__R1) + calc_G(__PperpSquarediMinus1, S123)), S123)
if (__PperpSquaredi >
S123 / 4.0): ##The maximum physically possible!
__notChosen2 = True
__PperpSquarediMinus1 = __PperpSquaredi
continue #Re-run the while loop
if (
__PperpSquaredi <= __PperpSquarediMinus1
): ##Don't update __PperpSquaredi if fails as would start allowing higher values!
__notChosen2 = False ##Move on
if (__PperpSquaredi < __cutOff):
return None, None, None
__R2 = random.random()
__ymin, __ymax = -0.5 * math.log(
S123 / __PperpSquaredi), 0.5 * math.log(S123 / __PperpSquaredi)
__yi = calc_inv_G2(__R2 * (calc_G2(__ymax) - calc_G2(__ymin)) +
calc_G2(__ymin))
if not check_rapidity_allowed(
S123, __PperpSquaredi,
__yi): ##Veto incorrect y-range. On the boundary is allowed.
__PperpSquarediMinus1 = __PperpSquaredi
continue ##Don't accept, notChosen1 == True, while will run again.
__R3 = random.random()
__numberCSIds = len(difCrossSecIds)
__ratio = sum_cSs(difCrossSecIds, S123, __PperpSquaredi, __yi, code1,
code2) / __numberCSIds * calc_g(
__PperpSquaredi, __yi)
if (__ratio <= __R3):
__PperpSquarediMinus1 = __PperpSquaredi
continue ##Don't accept, notChosen1 == True, while will run again.
else:
__notChosen1 = False ##Accept.
##Prepare weights for choosing Id of process occuring:
__idWeights = {} ##Empty dictionary initiated.
for __difCrossSecId in difCrossSecIds: ##Uses the Ids given so will weight for the chosen set.
__idWeights[__difCrossSecId] = sum_cSs([__difCrossSecId], S123,
__PperpSquaredi, __yi, code1,
code2)
__total = sum(__idWeights.itervalues())
__idWeights.update(
(x, y / __total) for x, y in __idWeights.items()) ##Normalise them
assert precision.check_numbers_equal(
sum(__idWeights.itervalues()),
1.0) ##i.e they should now be normalised to 1.
##Choose which process:
__R4 = random.random(
) ##Doesn't include 1 -> using < not <= for checks is fair.
__sumSoFar = 0.0
__chosenId = None
__chosen = False
if (logCrosSecs == 1):
crossSecsGluSplit.store(qg_to_qQQBar_cS(S123, __PperpSquaredi, __yi))
crossSecsGluProd.store(qg_to_qgg_cS(S123, __PperpSquaredi, __yi))
for __difCrossSecId in difCrossSecIds:
if (not __chosen):
__sumSoFar += __idWeights[__difCrossSecId]
if (__R4 < __sumSoFar):
__chosenId = __difCrossSecId
__chosen = True
assert (not (__chosenId == None)) ##Should have chosen by now!
return __PperpSquaredi, __yi, __chosenId
def __init__(self):
"""A function to initiate a four-loop strong coupling constant."""
self.__fourLoopLambda = constants.four_loop_lambda()
self.__showerCutOffEnergy = constants.cut_off_energy()
self.__alphaSMax = self.calculate(self.__showerCutOffEnergy *
self.__showerCutOffEnergy)
def __init__(self): """A function to initiate a two-loop strong coupling constant.""" self.__twoLoopAlphaSOfMz = constants.two_loop_alphaS_of_Mz() self.__showerCutOffEnergy = constants.cut_off_energy() self.__alphaSMax = self.calculate(self.__showerCutOffEnergy*self.__showerCutOffEnergy)
##Begin testing:##
print "\n----------------------------------------------------------------------"
print "----------------------------------------------------------------------\n"
print "////////////////////////////////"
print "Testing runningCouplings module:"
print "////////////////////////////////"
assertions.pause(__name__)
##Setup here:##
print "\nGenerating test values..."
tOneLoopAlphaS = oneLoopAlphaS()
tOneLoopAlphaEM = oneLoopAlphaEM()
tTwoLoopAlphaS = twoLoopAlphaS()
tFourLoopAlphaS = fourLoopAlphaS()
tCutOffEnergy = constants.cut_off_energy()
tQRange = range(2, 3700, 1)
tNfQRange = range(0, 3700000, 100)
tNfs, tOneLoopAlphaSs, tTwoLoopAlphaSs = [], [], []
tOneLoopAlphaEMs = []
tFourLoopAlphaSs, tDifferenceInAlphaSs = [], []
tOneLoopWeightedAlphaSs, tTwoLoopWeightedAlphaSs, tFourLoopWeightedAlphaSs = [], [], []
tOneLoopWeightedAlphaEMs = []
tBeta0s, tLns, tDenoms = [], [], []
tZBosonMass = particleData.knownParticles.get_mass_from_code(
particleData.knownParticles.get_code_from_name('Z-boson'))
tZBosonMassSquared = tZBosonMass * tZBosonMass
for tN1, tX1 in enumerate(tQRange):
tQRange[tN1] = (tQRange[tN1] / 10.0)
tOneLoopAlphaSs.append(tOneLoopAlphaS.calculate(tQRange[tN1]**2))
tOneLoopAlphaEMs.append(tOneLoopAlphaEM.calculate(tQRange[tN1]**2))
def __init__(self): """A function to initiate a four-loop strong coupling constant.""" self.__fourLoopLambda = constants.four_loop_lambda() self.__showerCutOffEnergy = constants.cut_off_energy() self.__alphaSMax = self.calculate(self.__showerCutOffEnergy*self.__showerCutOffEnergy)
def solve_sudakovs(PperpSquaredMax,S123,difCrossSecIds,code1,code2,logCrosSecs = None):
"""A function to generate a PperpSquared and y for an emission or splitting, using the Sudakov form factor."""
##Codes 1,2 still needed to get the charges for EM radiation.
##Using veto algorithm in "PYTHIA 6.0 Physics and Manual".
##And p198 of "Monte Carlo simulations of hard QCD radiation" for bivariant algorithm.
##And p16 of "Initial-state showering based on colour dipoles connected to incoming parton lines" for real y limits.
##And p5 of "Fooling around with the Sudakov veto algorithm" for multiple emission form.
assert assertions.all_are_numbers([PperpSquaredMax,S123])
assert (type(difCrossSecIds) == list)
__kQs = particleData.knownParticles.get_known_quarks()
__gC = particleData.knownParticles.get_code_from_name('gluon')
__expectedCodes = __kQs + [-x for x in __kQs] + [__gC]
assert ((code1 in __expectedCodes) and (code2 in __expectedCodes))
__cutOff = constants.cut_off_energy()*constants.cut_off_energy()
if (PperpSquaredMax < __cutOff):
return None, None, None
__notChosen1, __y, __PperpSquaredi = True, 0, assertions.force_float_number(PperpSquaredMax)
__PperpSquarediMinus1 = __PperpSquaredi
while __notChosen1: ##i += 1
__notChosen2 = True
while __notChosen2:
__R1 = random.random()
__PperpSquaredi = calc_inv_G((math.log(__R1) + calc_G(__PperpSquarediMinus1,S123)),S123)
if (__PperpSquaredi > S123/4.0): ##The maximum physically possible!
__notChosen2 = True
__PperpSquarediMinus1 = __PperpSquaredi
continue #Re-run the while loop
if (__PperpSquaredi <= __PperpSquarediMinus1): ##Don't update __PperpSquaredi if fails as would start allowing higher values!
__notChosen2 = False ##Move on
if (__PperpSquaredi < __cutOff):
return None, None, None
__R2 = random.random()
__ymin, __ymax = -0.5*math.log(S123/__PperpSquaredi), 0.5*math.log(S123/__PperpSquaredi)
__yi = calc_inv_G2(__R2*(calc_G2(__ymax) - calc_G2(__ymin)) + calc_G2(__ymin))
if not check_rapidity_allowed(S123,__PperpSquaredi,__yi): ##Veto incorrect y-range. On the boundary is allowed.
__PperpSquarediMinus1 = __PperpSquaredi
continue ##Don't accept, notChosen1 == True, while will run again.
__R3 = random.random()
__numberCSIds = len(difCrossSecIds)
__ratio = sum_cSs(difCrossSecIds,S123,__PperpSquaredi,__yi,code1,code2) / __numberCSIds*calc_g(__PperpSquaredi,__yi)
if (__ratio <= __R3):
__PperpSquarediMinus1 = __PperpSquaredi
continue ##Don't accept, notChosen1 == True, while will run again.
else:
__notChosen1 = False ##Accept.
##Prepare weights for choosing Id of process occuring:
__idWeights = {} ##Empty dictionary initiated.
for __difCrossSecId in difCrossSecIds: ##Uses the Ids given so will weight for the chosen set.
__idWeights[__difCrossSecId] = sum_cSs([__difCrossSecId],S123,__PperpSquaredi,__yi,code1,code2)
__total = sum(__idWeights.itervalues())
__idWeights.update((x, y/__total) for x, y in __idWeights.items()) ##Normalise them
assert precision.check_numbers_equal(sum(__idWeights.itervalues()),1.0) ##i.e they should now be normalised to 1.
##Choose which process:
__R4 = random.random() ##Doesn't include 1 -> using < not <= for checks is fair.
__sumSoFar = 0.0
__chosenId = None
__chosen = False
if (logCrosSecs == 1):
crossSecsGluSplit.store(qg_to_qQQBar_cS(S123,__PperpSquaredi,__yi))
crossSecsGluProd.store(qg_to_qgg_cS(S123,__PperpSquaredi,__yi))
for __difCrossSecId in difCrossSecIds:
if (not __chosen):
__sumSoFar += __idWeights[__difCrossSecId]
if (__R4 < __sumSoFar):
__chosenId = __difCrossSecId
__chosen = True
assert (not (__chosenId == None)) ##Should have chosen by now!
return __PperpSquaredi, __yi, __chosenId
def __init__(self):
"""A function to initiate a two-loop strong coupling constant."""
self.__twoLoopAlphaSOfMz = constants.two_loop_alphaS_of_Mz()
self.__showerCutOffEnergy = constants.cut_off_energy()
self.__alphaSMax = self.calculate(self.__showerCutOffEnergy *
self.__showerCutOffEnergy)
