def __init__(self,nameToSet,massToSet = 0.0,widthToSet = 0.0,chargeToSet = 0.0,spinToSet = 0.0): """A function to initiate a PDG entry. Only particles not anti-knownParticles.""" assert (type(nameToSet) == str) assert assertions.all_are_numbers([massToSet,widthToSet,chargeToSet,spinToSet]) self.__name = nameToSet self.__mass = assertions.force_float_number(massToSet) self.__width = assertions.force_float_number(widthToSet) self.__charge = assertions.force_float_number(chargeToSet) self.__spin = assertions.force_float_number(spinToSet)
def __init__(self,
nameToSet,
massToSet=0.0,
widthToSet=0.0,
chargeToSet=0.0,
spinToSet=0.0):
"""A function to initiate a PDG entry. Only particles not anti-knownParticles."""
assert (type(nameToSet) == str)
assert assertions.all_are_numbers(
[massToSet, widthToSet, chargeToSet, spinToSet])
self.__name = nameToSet
self.__mass = assertions.force_float_number(massToSet)
self.__width = assertions.force_float_number(widthToSet)
self.__charge = assertions.force_float_number(chargeToSet)
self.__spin = assertions.force_float_number(spinToSet)
def calculate(self, Q):
"""A function for calculating the two-loop strong coupling constant at a given COM energy squared."""
##Source: Paper 'Measurements of the strong coupling constant and the QCD colour factors using four-jet..
##..observables from hadronic Z decays', p4, equations 2-5.
##Unlike the others, these equations are given as a function of Q not Q^2 and so use Mz and alphaS(Mz).
assert assertions.all_are_numbers([Q])
__Q = assertions.force_float_number(Q)
__Nf, __Cf, __twoLoopAlphaSOfMz = Nf(
__Q * __Q), constants.Cf(), self.__twoLoopAlphaSOfMz
__Mz = particleData.knownParticles.get_mass_from_code(
particleData.knownParticles.get_code_from_name('Z-boson'))
##Adjust betas to those of this paper:
__beta0 = beta0(__Nf) / __Cf
__beta1 = beta1(__Nf) / (2.0 * __Cf * __Cf)
try:
assert assertions.safe_division(__Q)
__ln1 = math.log(__Mz / __Q)
__wOfQ = 1.0 - (__beta0 * __twoLoopAlphaSOfMz * __Cf * __ln1 /
(2.0 * math.pi))
__denominator4 = __beta0 * 2.0 * math.pi * __wOfQ
assert assertions.safe_division(__denominator4)
__term1 = 1.0 - (__beta1 * __twoLoopAlphaSOfMz * __Cf *
math.log(__wOfQ) / __denominator4)
__denominator5 = __wOfQ
assert assertions.safe_division(__denominator5)
__result = __twoLoopAlphaSOfMz * __term1 / __denominator5
return __result
except:
##Breaks down below the cut-off energy as expected.
print "Error in two-loop at Q =", __Q
return -1.0
def calculate(self,QSquared): """A function for calculating the four-loop strong coupling constant at a given COM energy squared.""" ##Using approximate analytic solution. ##Source: 'Quantum Chromodynamics', Dissertori Group, Lpthe Group, P Salam, p3, equation 9.5. assert assertions.all_are_numbers([QSquared]) __QSquared = assertions.force_float_number(QSquared) __Nf, __pi = Nf(__QSquared), math.pi __beta0 = beta0(__Nf) / (4.0*__pi) __beta1 = beta1(__Nf) / ((4.0*__pi)*(4.0*__pi)) __beta2 = beta2(__Nf) / ((4.0*__pi)*(4.0*__pi)*(4.0*__pi)) __beta3 = beta3(__Nf) / ((4.0*__pi)*(4.0*__pi)*(4.0*__pi)*(4.0*__pi)) try: __denominator6 = (self.__fourLoopLambda*self.__fourLoopLambda) assert assertions.safe_division(__denominator6) __ln = math.log(__QSquared/__denominator6) __denominator7 = __beta0*__beta0*__ln assert assertions.safe_division(__denominator7) __term1 = __beta1*math.log(__ln)/__denominator7 __denominator8 = __beta0*__beta0*__beta0*__beta0*__ln*__ln assert assertions.safe_division(__denominator8) __term2 = ((__beta1*__beta1 * ((math.log(__ln)*math.log(__ln)) - math.log(__ln) - 1.0)) + __beta0*__beta2) / __denominator8 __term3P1 = (math.log(__ln)*math.log(__ln)*math.log(__ln)) - (5.0/2.0)*math.log(__ln)*math.log(__ln) - 2.0*math.log(__ln) + 0.5 __denominator9 = (__beta0*__beta0*__beta0*__beta0*__beta0*__beta0*__ln*__ln*__ln) assert assertions.safe_division(__denominator9) __term3 = (__beta1*__beta1*__beta1 * __term3P1) / __denominator9 __term4 = ((3.0*__beta0*__beta1*__beta2*math.log(__ln)) - (0.5*__beta0*__beta0*__beta3)) / __denominator9 __denominator10 = __beta0*__ln assert assertions.safe_division(__denominator10) __result = (1.0 - __term1 + __term2 - (__term3 + __term4)) / __denominator10 return __result except: print "Error in four-loop at QSquared =", __QSquared return -1.0
def calculate(self,Q):
"""A function for calculating the two-loop strong coupling constant at a given COM energy squared."""
##Source: Paper 'Measurements of the strong coupling constant and the QCD colour factors using four-jet..
##..observables from hadronic Z decays', p4, equations 2-5.
##Unlike the others, these equations are given as a function of Q not Q^2 and so use Mz and alphaS(Mz).
assert assertions.all_are_numbers([Q])
__Q = assertions.force_float_number(Q)
__Nf, __Cf, __twoLoopAlphaSOfMz = Nf(__Q*__Q), constants.Cf(), self.__twoLoopAlphaSOfMz
__Mz = particleData.knownParticles.get_mass_from_code(particleData.knownParticles.get_code_from_name('Z-boson'))
##Adjust betas to those of this paper:
__beta0 = beta0(__Nf) / __Cf
__beta1 = beta1(__Nf) / (2.0*__Cf*__Cf)
try:
assert assertions.safe_division(__Q)
__ln1 = math.log(__Mz/__Q)
__wOfQ = 1.0 - (__beta0*__twoLoopAlphaSOfMz*__Cf*__ln1 / (2.0* math.pi))
__denominator4 = __beta0*2.0*math.pi*__wOfQ
assert assertions.safe_division(__denominator4)
__term1 = 1.0 - (__beta1*__twoLoopAlphaSOfMz*__Cf*math.log(__wOfQ)/__denominator4)
__denominator5 = __wOfQ
assert assertions.safe_division(__denominator5)
__result = __twoLoopAlphaSOfMz*__term1 / __denominator5
return __result
except:
##Breaks down below the cut-off energy as expected.
print "Error in two-loop at Q =", __Q
return -1.0
def force_float_vector(self):
"""A function to convert all vector integers to floats but leave doubles."""
for __i2 in range(4):
assert assertions.all_are_numbers([__i2])
if (not assertions.check_float(self.__vector[__i2])):
self.__vector[__i2] = assertions.force_float_number(
self.__vector[__i2])
def __setitem__(self, i6, newValue):
"""A function to assign an entry in a four-vector object."""
assert assertions.valid_four_vector_index(i6)
assert assertions.all_are_numbers([newValue])
__newValue = assertions.force_float_number(newValue)
self.__vector[i6] = __newValue
self.__positionsEmpty[i6] = False
self.update_empty()
def __setitem__(self, i6, newValue): """A function to assign an entry in a four-vector object.""" assert assertions.valid_four_vector_index(i6) assert assertions.all_are_numbers([newValue]) __newValue = assertions.force_float_number(newValue) self.__vector[i6] = __newValue self.__positionsEmpty[i6] = False self.update_empty()
def __imul__(self,multiplier): ##Used for *= """A function for multiplying a four-vector by a scalar.""" assert assertions.all_are_numbers([multiplier]) assert self.__nonzero__() __multiplier = assertions.force_float_number(multiplier) for __i7 in range(4): self[__i7] *= __multiplier return self
def __imul__(self, multiplier): ##Used for *=
"""A function for multiplying a four-vector by a scalar."""
assert assertions.all_are_numbers([multiplier])
assert self.__nonzero__()
__multiplier = assertions.force_float_number(multiplier)
for __i7 in range(4):
self[__i7] *= __multiplier
return self
def __idiv__(self, denominator): ##Used for /=
"""A function for dividing a four-vector by a scalar."""
assert assertions.all_are_numbers([denominator])
assert assertions.safe_division(denominator)
assert self.__nonzero__()
__denominator = assertions.force_float_number(denominator)
for __i8 in range(4):
self[__i8] /= __denominator
return self
def __idiv__(self,denominator): ##Used for /= """A function for dividing a four-vector by a scalar.""" assert assertions.all_are_numbers([denominator]) assert assertions.safe_division(denominator) assert self.__nonzero__() __denominator = assertions.force_float_number(denominator) for __i8 in range(4): self[__i8] /= __denominator return self
def __div__(self,denominator): ##Used for fVA / denominator. """A function for dividing a four-vector by a scalar.""" assert assertions.all_are_numbers([denominator]) assert assertions.safe_division(denominator) assert self.__nonzero__() __denominator = assertions.force_float_number(denominator) __result3 = self.copy() __result3 /= __denominator return __result3
def __div__(self, denominator): ##Used for fVA / denominator.
"""A function for dividing a four-vector by a scalar."""
assert assertions.all_are_numbers([denominator])
assert assertions.safe_division(denominator)
assert self.__nonzero__()
__denominator = assertions.force_float_number(denominator)
__result3 = self.copy()
__result3 /= __denominator
return __result3
def calculate(self,QSquared):
"""A function for calculating the one-loop fine structure constant at a given COM energy squared."""
##Source: "https://www.ippp.dur.ac.uk/~krauss/Lectures/QuarksLeptons/QCD/AsymptoticFreedom_1.html".
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__Mz = particleData.knownParticles.get_mass_from_code(particleData.knownParticles.get_code_from_name('Z-boson'))
__ln = math.log(__QSquared/(__Mz*__Mz))
__denominator = 1.0 - (self.__oneLoopAlphaEMOfMzSquared*__ln/(3.0*math.pi))
return self.__oneLoopAlphaEMOfMzSquared / __denominator
def Nf(QSquared): """A function to return the number of quark flavours that can be produced given a centre of mass energy squared.""" assert assertions.all_are_numbers([QSquared]) __QSquared = assertions.force_float_number(QSquared) __nf = 0 for __quarkCode in particleData.knownParticles.get_known_quarks(): __quarkMass = particleData.knownParticles.get_mass_from_code(__quarkCode) if (2.0*__quarkMass < math.sqrt(__QSquared)): __nf += 1 return __nf
def calculate(self, QSquared):
"""A function for calculating the one-loop fine structure constant at a given COM energy squared."""
##Source: "https://www.ippp.dur.ac.uk/~krauss/Lectures/QuarksLeptons/QCD/AsymptoticFreedom_1.html".
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__Mz = particleData.knownParticles.get_mass_from_code(
particleData.knownParticles.get_code_from_name('Z-boson'))
__ln = math.log(__QSquared / (__Mz * __Mz))
__denominator = 1.0 - (self.__oneLoopAlphaEMOfMzSquared * __ln /
(3.0 * math.pi))
return self.__oneLoopAlphaEMOfMzSquared / __denominator
def Nf(QSquared):
"""A function to return the number of quark flavours that can be produced given a centre of mass energy squared."""
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__nf = 0
for __quarkCode in particleData.knownParticles.get_known_quarks():
__quarkMass = particleData.knownParticles.get_mass_from_code(
__quarkCode)
if (2.0 * __quarkMass < math.sqrt(__QSquared)):
__nf += 1
return __nf
def calculate(self,QSquared):
"""A function for calculating the one-loop strong coupling constant at a given COM energy squared."""
##Source: 'Determination of the QCD coupling alphaS'.
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__Nf= Nf(__QSquared)
__Mz = particleData.knownParticles.get_mass_from_code(particleData.knownParticles.get_code_from_name('Z-boson'))
##Encorporate in factor of 1/4Pi to make the beta function match:
__beta0 = beta0(__Nf) / (4.0*math.pi)
__denominator1 = (__Mz*__Mz)
__ln = math.log(__QSquared/__denominator1)
__denominator2 = 1.0 + (self.__oneLoopAlphaSOfMzSquared * __beta0 * __ln)
return self.__oneLoopAlphaSOfMzSquared / __denominator2
def calculate(self, QSquared):
"""A function for calculating the one-loop strong coupling constant at a given COM energy squared."""
##Source: 'Determination of the QCD coupling alphaS'.
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__Nf = Nf(__QSquared)
__Mz = particleData.knownParticles.get_mass_from_code(
particleData.knownParticles.get_code_from_name('Z-boson'))
##Encorporate in factor of 1/4Pi to make the beta function match:
__beta0 = beta0(__Nf) / (4.0 * math.pi)
__denominator1 = (__Mz * __Mz)
__ln = math.log(__QSquared / __denominator1)
__denominator2 = 1.0 + (self.__oneLoopAlphaSOfMzSquared * __beta0 *
__ln)
return self.__oneLoopAlphaSOfMzSquared / __denominator2
def calculate(self, QSquared):
"""A function for calculating the four-loop strong coupling constant at a given COM energy squared."""
##Using approximate analytic solution.
##Source: 'Quantum Chromodynamics', Dissertori Group, Lpthe Group, P Salam, p3, equation 9.5.
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
__Nf, __pi = Nf(__QSquared), math.pi
__beta0 = beta0(__Nf) / (4.0 * __pi)
__beta1 = beta1(__Nf) / ((4.0 * __pi) * (4.0 * __pi))
__beta2 = beta2(__Nf) / ((4.0 * __pi) * (4.0 * __pi) * (4.0 * __pi))
__beta3 = beta3(__Nf) / ((4.0 * __pi) * (4.0 * __pi) * (4.0 * __pi) *
(4.0 * __pi))
try:
__denominator6 = (self.__fourLoopLambda * self.__fourLoopLambda)
assert assertions.safe_division(__denominator6)
__ln = math.log(__QSquared / __denominator6)
__denominator7 = __beta0 * __beta0 * __ln
assert assertions.safe_division(__denominator7)
__term1 = __beta1 * math.log(__ln) / __denominator7
__denominator8 = __beta0 * __beta0 * __beta0 * __beta0 * __ln * __ln
assert assertions.safe_division(__denominator8)
__term2 = ((__beta1 * __beta1 * (
(math.log(__ln) * math.log(__ln)) - math.log(__ln) - 1.0)) +
__beta0 * __beta2) / __denominator8
__term3P1 = (math.log(__ln) * math.log(__ln) * math.log(__ln)
) - (5.0 / 2.0) * math.log(__ln) * math.log(
__ln) - 2.0 * math.log(__ln) + 0.5
__denominator9 = (__beta0 * __beta0 * __beta0 * __beta0 * __beta0 *
__beta0 * __ln * __ln * __ln)
assert assertions.safe_division(__denominator9)
__term3 = (__beta1 * __beta1 * __beta1 *
__term3P1) / __denominator9
__term4 = ((3.0 * __beta0 * __beta1 * __beta2 * math.log(__ln)) -
(0.5 * __beta0 * __beta0 * __beta3)) / __denominator9
__denominator10 = __beta0 * __ln
assert assertions.safe_division(__denominator10)
__result = (1.0 - __term1 + __term2 -
(__term3 + __term4)) / __denominator10
return __result
except:
print "Error in four-loop at QSquared =", __QSquared
return -1.0
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 calculate_weighted(self,QSquared): """A function to return the one-loop fine structure constant weighted on it's maximum value (at Mz^2).""" ##Currently only set for showering on resonance with the Z-boson channel. assert assertions.all_are_numbers([QSquared]) __QSquared = assertions.force_float_number(QSquared) return self.calculate(__QSquared) / self.__alphaEMMax
def calculate_weighted(self,QSquared): """A function to return the four-loop strong coupling constant weighted on it's maximum value (at parton shower cutoff).""" assert assertions.all_are_numbers([QSquared]) __QSquared = assertions.force_float_number(QSquared) return self.calculate(__QSquared) / self.__alphaSMax
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 calculate_weighted(self, QSquared):
"""A function to return the one-loop fine structure constant weighted on it's maximum value (at Mz^2)."""
##Currently only set for showering on resonance with the Z-boson channel.
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
return self.calculate(__QSquared) / self.__alphaEMMax
def calculate_weighted(self, QSquared):
"""A function to return the four-loop strong coupling constant weighted on it's maximum value (at parton shower cutoff)."""
assert assertions.all_are_numbers([QSquared])
__QSquared = assertions.force_float_number(QSquared)
return self.calculate(__QSquared) / self.__alphaSMax
def check_v_not_faster_than_c(scalarVelocity):
"""A function to check that a scalar velocity isn't faster than the speed of light."""
##Allows equal to the speed of light to accommodate massless particles.
assert assertions.all_are_numbers([scalarVelocity])
__scalarVelocity = assertions.force_float_number(scalarVelocity)
return (__scalarVelocity <= 1.0)
def force_float_vector(self): """A function to convert all vector integers to floats but leave doubles.""" for __i2 in range(4): assert assertions.all_are_numbers([__i2]) if (not assertions.check_float(self.__vector[__i2])): self.__vector[__i2] = assertions.force_float_number(self.__vector[__i2])
def check_v_not_faster_than_c(scalarVelocity): """A function to check that a scalar velocity isn't faster than the speed of light.""" ##Allows equal to the speed of light to accommodate massless particles. assert assertions.all_are_numbers([scalarVelocity]) __scalarVelocity = assertions.force_float_number(scalarVelocity) return (__scalarVelocity <= 1.0)
