def GammaG2S0S0Int(n, M5, k, kR):
if Basic.m(n, M5, k) < Basic.m(0, M5, k) + Basic.m(0, M5, k):
return 0
else:
return (8 * k**4 * n**2 * (-23 * kR**2 + 9 * n**2)**
(5 / 2)) / (3645 * M5**3 * (kR**2 + n**2)**2 *
(25 * kR**2 + 9 * n**2)**2 * math.pi**2)
def Gamma(n, M5, k):
#Partial widths
total = Basic.PS2SM(Basic.m(n, M5, k)) * Basic.Gamma0(n, M5, k)
total += KKcascade.GammaG2GG(n, M5, k)
total += KKcascade.GammaG2SG(n, M5, k)
total += KKcascade.GammaG2S0Gfast(n, M5, k)
#Return total
return total
def GammaG2S0SInt(n, a, M5, k, kR):
if Basic.m(n, M5, k) < Basic.m(a, M5, k) + Basic.m(0, M5, k):
return 0
else:
return (64 * a**2 * k**4 * kR * n**2 *
(-9 * (18 * a**2 + 25 * kR**2) + 81 * n**2 +
(9 * a**2 + kR**2)**2 / (kR**2 + n**2))**
(5 / 2)) / (3645 * (a**2 + kR**2) *
(9 * a**2 + kR**2) * M5**3 *
(81 * a**4 + 18 * a**2 * (16 * kR**2 - 9 * n**2) +
(16 * kR**2 + 9 * n**2)**2)**2 * math.pi**3)
def GammaG2SGInt(n, a, b, M5, k, kR):
if Basic.m(n, M5, k) < Basic.m(a, M5, k) + Basic.m(b, M5, k):
return 0
elif a == 0:
return (
8 * b**2 * k**4 * n**2 *
(955 * kR**4 + 171 * kR**2 * n**2 + 9 * b**2 *
(19 * kR**2 + 3 * n**2))**2 *
math.sqrt(81 * b**4 - 224 * kR**4 - 144 * kR**2 * n**2 +
81 * n**4 - 18 * b**2 * (8 * kR**2 + 9 * n**2)) *
(6561 * b**8 + 686836 * kR**8 + 1532232 * kR**6 * n**2 + 1012338 *
kR**4 * n**4 + 173502 * kR**2 * n**6 + 6561 * n**8 + 1458 * b**6 *
(119 * kR**2 + 117 * n**2) + 486 * b**4 *
(2083 * kR**4 + 3783 * kR**2 * n**2 + 1701 * n**4) + 18 * b**2 *
(85124 * kR**6 + 177786 * kR**4 * n**2 + 102141 * kR**2 * n**4 +
9477 * n**6))) / (2657205 * kR * (b**2 + kR**2)**3 * M5**3 *
(kR**2 + n**2)**(9 / 2) *
(81 * b**4 + 18 * b**2 *
(16 * kR**2 - 9 * n**2) +
(16 * kR**2 + 9 * n**2)**2)**2 * math.pi**3)
else:
return (64 * a**2 * b**2 * k**4 * n**2 *
(kR**2 * (-16 * a**6 + a**4 * (42 * b**2 - 86 * kR**2) + a**2 *
(-45 * b**4 + 157 * b**2 * kR**2 - 54 * kR**4) +
(b**2 + kR**2) *
(19 * b**4 + 99 * b**2 * kR**2 + 16 * kR**4)) +
(3 * b**6 - 16 * b**4 * kR**2 - 160 * b**2 * kR**4 +
115 * kR**6 - 6 * a**4 * (b**2 - 7 * kR**2) + a**2 *
(b**2 + kR**2) * (3 * b**2 + 157 * kR**2)) * n**2 +
(3 * a**2 * (b**2 - 15 * kR**2) - 2 *
(3 * b**4 + 8 * b**2 * kR**2 - 59 * kR**4)) * n**4 +
(3 * b**2 + 19 * kR**2) * n**6)**2 *
math.sqrt(a**4 + b**4 - 3 * kR**4 - 2 * kR**2 * n**2 + n**4 -
2 * b**2 * (kR**2 + n**2) - 2 * a**2 *
(b**2 + kR**2 + n**2)) *
(a**8 + b**8 + 26 * b**6 * (kR**2 + n**2) - 4 * a**6 *
(b**2 + kR**2 + n**2) + 2 * b**2 * (kR**2 + n**2)**2 *
(111 * kR**2 + 13 * n**2) + 2 * b**4 * (kR**2 + n**2) *
(74 * kR**2 + 63 * n**2) + (kR**2 + n**2)**2 *
(99 * kR**4 + 24 * kR**2 * n**2 + n**4) + a**4 *
(6 * b**4 + 34 * b**2 * kR**2 + 28 * kR**4 + 34 *
(b**2 + kR**2) * n**2 + 6 * n**4) - 4 * a**2 *
(b**2 + kR**2 + n**2) *
(b**4 + 13 * b**2 * (kR**2 + n**2) + (kR**2 + n**2) *
(12 * kR**2 + n**2)))) / (1215 * (a**2 + kR**2) *
(9 * a**2 + kR**2) *
(b**2 + kR**2)**3 * M5**3 *
(kR**2 + (a + b - n)**2)**2 *
(kR**2 + n**2)**(9 / 2) *
(kR**2 + (a - b + n)**2)**2 *
(kR**2 + (-a + b + n)**2)**2 *
(kR**2 +
(a + b + n)**2)**2 * math.pi**4)
def GammaG2SGexact(n, M5, k):
total = 0
kR = k * Basic.R(M5, k)
for a in range(1, n):
for b in range(1, n):
total += GammaG2SGInt(n, a, b, M5, k, kR)
return total
def GammaG2SSInt(n, a, b, M5, k, kR):
if Basic.m(n, M5, k) < Basic.m(a, M5, k) + Basic.m(b, M5, k):
return 0
else:
return (8 * a**2 * b**2 * k**4 * n**2 *
(-2 * a**2 - 2 * b**2 - 3 * kR**2 + n**2 + (a**2 - b**2)**2 /
(kR**2 + n**2))**(5 / 2) *
(a**4 * (27 * b**2 + 11 * kR**2) + a**2 *
(27 * b**4 + 14 * kR**4 - 19 * kR**2 * n**2 + b**2 *
(65 * kR**2 - 27 * n**2)) + kR**2 *
(11 * b**4 + 3 * kR**4 + 5 * kR**2 * n**2 + 8 * n**4 + b**2 *
(14 * kR**2 - 19 * n**2)))**2) / (
135 * kR**2 * (a**2 + kR**2) * (9 * a**2 + kR**2) *
(b**2 + kR**2) * (9 * b**2 + kR**2) * M5**3 *
(kR**2 + (a + b - n)**2)**2 *
(kR**2 + (a - b + n)**2)**2 * (kR**2 +
(-a + b + n)**2)**2 *
(kR**2 + (a + b + n)**2)**2 * math.pi**4)
def m4A2(a, b, n, M5, k):
total = 0
for j in range(1, 5):
total += A2(j, (Basic.m(a, M5, k)**2 + Basic.m(b, M5, k)**2) /
Basic.m(n, M5, k)**2,
(Basic.m(a, M5, k)**2 - Basic.m(b, M5, k)**2) /
Basic.m(n, M5, k)**2)
return Basic.m(n, M5, k)**4 * total
def CrossSectionKKn(n, M5, k, listMass, pdf, S):
#Read constants
M = listMass[n]
q = M
#Calculate the luminosities
lumGG = Luminosity.ggLum(S, M, q, pdf)
lumUU = Luminosity.qqbarLum(S, M, q, 1, 1, pdf)
lumDD = Luminosity.qqbarLum(S, M, q, 2, 2, pdf)
#Return cross section (Eq. (2.57))
return M**2 * math.pi / (48 * Basic.Lambda2(n, M5, k)) * (
3 * lumGG + 4 * lumUU + 4 * lumDD) * Couplings.Gev2fb
def GammaG2SGapprox(n, M5, k):
return (1 -
k / Basic.m(n, M5, k))**16 / (2**5 * math.pi**2) * k**2 * Basic.m(
n, M5, k)**2 / (k * Basic.R(M5, k) * M5**3)
def PS(a, b, n, M5, k):
return 1 / (2 * Basic.m(n, M5, k)) * (
Basic.m(n, M5, k)**2 - 2 *
(Basic.m(a, M5, k)**2 + Basic.m(b, M5, k)**2) +
(Basic.m(a, M5, k)**2 - Basic.m(b, M5, k)**2)**2 /
Basic.m(n, M5, k)**2)**0.5
def Btt(n, M5, k, listGamma):
return 3 * Basic.PSffbar(Couplings.mtQ / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def BRnunu3(n, M5, k, listGamma):
return 1 / 2 * Basic.PSffbar(Couplings.mnu3 / Basic.m(
n, M5, k)) * Basic.Gamma0(n, M5, k) / listGamma[n]
def GammaG2GGapprox(n, M5, k):
return (1 - k / Basic.m(n, M5, k))**9 * (5 * 7 * 17) / (
3 * 2**14 * math.pi**2) * (k * Basic.m(n, M5, k))**0.5 * Basic.m(
n, M5, k)**3 / (k * Basic.R(M5, k) * M5**3)
def BRee(n, M5, k, listGamma):
return Basic.PSffbar(Couplings.me / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def BRWW(n, M5, k, listGamma):
return Basic.PSWW(Couplings.mW / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def BRgg(n, M5, k, listGamma):
return Basic.PSgg(Couplings.mg / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def GammaG2SSapprox(n, M5, k):
return (1 - k / Basic.m(n, M5, k))**16 / (
2**13 * math.pi**2) * (k * Basic.m(n, M5, k))**0.5 * k**2 * Basic.m(
n, M5, k) / (k * Basic.R(M5, k) * M5**3)
def GammaG2S0S0(n, M5, k):
return GammaG2S0S0Int(n, M5, k, k * Basic.R(M5, k))
def BRgammagamma(n, M5, k, listGamma):
return Basic.PSgammagamma() * Basic.Gamma0(n, M5, k) / listGamma[n]
def GammaG2SGapproxNLO(n, M5, k):
return (1 + k / Basic.m(n, M5, k))**3 * (
1 - 5 / 2 *
(k / Basic.m(n, M5, k))**0.5) / (2**5 * math.pi**2) * k**2 * Basic.m(
n, M5, k)**2 / (k * Basic.R(M5, k) * M5**3)
def BRZZ(n, M5, k, listGamma):
return Basic.PSZZ(Couplings.mZ / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def mm(z, M5, k):
return k**2 + z**2 / Basic.R(M5, k)**2
def BRhh(n, M5, k, listGamma):
return Basic.PShh(Couplings.mh / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def IMMC(a, b, n, M5, k):
return (32 / Basic.R(M5, k)**3) * k * n * Basic.m(n, M5, k) * a * Basic.m(
a, M5, k) * b * Basic.m(b, M5, k) / (mm(a + b - n, M5, k) * mm(
a - b + n, M5, k) * mm(b + n - a, M5, k) * mm(a + b + n, M5, k))
def BRtautau(n, M5, k, listGamma):
return Basic.PSffbar(Couplings.mtau / Basic.m(n, M5, k)) * Basic.Gamma0(
n, M5, k) / listGamma[n]
def AT2(a, b, n, M5, k):
return 1 / 5 * IMMC(
a, b, n, M5, k)**2 / (M5 * math.pi * Basic.R(M5, k))**3 * (
m4A2(a, b, n, M5, k) + m4A2(b, n, a, M5, k) + m4A2(n, a, b, M5, k))
def Sfix(M5, k, massList):
#Parameter
SLHC = Couplings.SLHC
Eff = Couplings.Eff
Intlum = Couplings.Intlum
#Load pdf information
print(os.getcwd())
pdf = mkPDF('MSTW2008lo68cl', 0, pdfdir=os.getcwd() + '/v8')
#Calculate masses of KK gravitons
listMassKK = [0]
mtemp = 0
nint = 1
while mtemp < massList[-1]:
mtemp = Basic.m(nint, M5, k)
listMassKK.append(mtemp)
nint += 1
#Calculate decay widths, branching ratios to photons and cross sections
listGamma = [0]
listBRPhotons = [0]
listCS = [0]
for n in range(1, len(listMassKK)):
listGamma.append(Graviton.Gamma(n, M5, k))
listBRPhotons.append(Graviton.BRgammagamma(n, M5, k, listGamma))
listCS.append(Graviton.CrossSectionKKn(n, M5, k, listMassKK, pdf,
SLHC))
#Write properties
if Couplings.writeProp:
ftemp = open("GravitonProperties.txt", "w")
ftemp.write("Summary of the graviton properties \n")
ftemp.write(
"n mass Decay width Cross section [fb] BR to photons \n"
)
for n in range(0, len(listMassKK)):
ftemp.write(
str(n) + " " + str(listMassKK[n]) + " " + str(listGamma[n]) +
" " + str(listCS[n]) + " " + str(listBRPhotons[n]) + " " +
"\n")
ftemp.close()
#Apply smearing
listS = []
listCSplot = []
for i in range(0, len(massList) - 1):
#Initialize variables
total = 0
mass = massList[i]
deltamass = massList[i + 1] - massList[i]
#Sum over particles
for particle in range(1, len(listMassKK)):
total += listCS[particle] * Smearing.shape(
mass, listMassKK[particle],
listGamma[particle]) * listBRPhotons[particle] * Eff * Intlum
#Append to lists
listS.append(total * deltamass)
listCSplot.append(total / Intlum)
#Calculate parton luminosity
lum = []
for mass in massList:
lum.append(
Luminosity.ggLum(SLHC, mass, mass, pdf) +
4 / 3 * Luminosity.qqbarLum(SLHC, mass, mass, 1, 1, pdf) +
4 / 3 * Luminosity.qqbarLum(SLHC, mass, mass, 2, 2, pdf))
#Make plot
if Couplings.makePlot:
massListR = numpy.delete(massList, -1)
plt.plot(massListR, listCSplot)
axes = plt.gca()
plt.xlabel('$m_{\gamma\gamma}$ [GeV]')
plt.ylabel(' d$\sigma$/dm x $\epsilon$ x BR[fb/GeV]')
plt.savefig('Signal.pdf')
plt.clf()
#Return
return listS, lum
def GammaG2GGInt(n, a, b, M5, k):
if Basic.m(n, M5, k) < Basic.m(a, M5, k) + Basic.m(b, M5, k):
return 0
else:
return PS(a, b, n, M5, k) / (16 * math.pi * Basic.m(n, M5, k)) * AT2(
a, b, n, M5, k)
