# CHEIDI: HEIDI_bundle.fr

File HEIDI_bundle.fr, 12.5 KB (added by ChristianSpeckner, 10 years ago) |
---|

Line | |
---|---|

1 | (* Automatically generated from HDecay output * |

2 | * (c.f. "HDECAY: A Program for Higgs boson decays in the standard model and * |

3 | * its supersymmetric extension.", A. Djouadi, J. Kalinowski, M. Spira, * |

4 | * Comput.Phys.Commun.108:56-74,1998) *) |

5 | |

6 | BeginPackage ["Hdecay`"]; |

7 | Begin ["Hdecay`p`"]; |

8 | |

9 | data = {{0, 0}, {1., 2.251*^-7}, {6.0201, 0.00002011}, {11.0402, 0.0001738}, {16.0603, 0.0004549}, |

10 | {21.0804, 0.0006405}, {26.1005, 0.0007918}, {31.1206, 0.0009277}, {36.1407, 0.001055}, |

11 | {41.1608, 0.001178}, {46.1809, 0.001298}, {51.201, 0.001416}, {56.2211, 0.001533}, |

12 | {61.2412, 0.001649}, {66.2613, 0.001766}, {71.2814, 0.001883}, {76.3015, 0.002}, |

13 | {81.3216, 0.002119}, {86.3417, 0.00224}, {91.3618, 0.002364}, {96.3819, 0.002495}, |

14 | {101.402, 0.002642}, {106.422, 0.002816}, {111.442, 0.003041}, {116.462, 0.003347}, |

15 | {121.482, 0.003782}, {126.503, 0.00442}, {131.523, 0.005373}, {136.543, 0.00683}, |

16 | {141.563, 0.009133}, {146.583, 0.013}, {151.603, 0.02027}, {156.623, 0.03847}, |

17 | {161.643, 0.1316}, {166.663, 0.2903}, {171.683, 0.4168}, {176.704, 0.5386}, |

18 | {181.724, 0.6883}, {186.744, 0.9035}, {191.764, 1.105}, {196.784, 1.3}, {201.804, 1.499}, |

19 | {206.824, 1.705}, {211.844, 1.922}, {216.864, 2.151}, {221.884, 2.394}, {226.905, 2.651}, |

20 | {231.925, 2.924}, {236.945, 3.213}, {241.965, 3.519}, {246.985, 3.843}, {252.005, 4.184}, |

21 | {257.025, 4.545}, {262.045, 4.925}, {267.065, 5.324}, {272.085, 5.742}, {277.106, 6.182}, |

22 | {282.126, 6.642}, {287.146, 7.123}, {292.166, 7.625}, {297.186, 8.15}, {302.206, 8.696}, |

23 | {307.226, 9.265}, {312.246, 9.856}, {317.266, 10.47}, {322.286, 11.1}, {327.307, 11.76}, |

24 | {332.327, 12.44}, {337.347, 13.13}, {342.367, 13.83}, {347.387, 14.61}, {352.407, 15.7}, |

25 | {357.427, 16.91}, {362.447, 18.18}, {367.467, 19.51}, {372.487, 20.89}, {377.508, 22.31}, |

26 | {382.528, 23.77}, {387.548, 25.27}, {392.568, 26.81}, {397.588, 28.38}, {402.608, 29.99}, |

27 | {407.628, 31.63}, {412.648, 33.3}, {417.668, 35.01}, {422.688, 36.76}, {427.709, 38.53}, |

28 | {432.729, 40.34}, {437.749, 42.19}, {442.769, 44.06}, {447.789, 45.97}, {452.809, 47.92}, |

29 | {457.829, 49.9}, {462.849, 51.91}, {467.869, 53.96}, {472.889, 56.05}, {477.91, 58.17}, |

30 | {482.93, 60.33}, {487.95, 62.52}, {492.97, 64.76}, |

31 | {497.99, 67.03}}; |

32 | |

33 | interpolation[x_, l_] := Plus @@ ((#[[1]] * x^#[[2]])& /@ l); |

34 | |

35 | params = {{-0.26293901351164234, 1}, {0.001368182199849752, 2}, {-2.3048363155706936*^-6, 3}, |

36 | {3.1498414039397794*^-9, 4}, {-1.977234012939224*^-12, 5}, |

37 | {6.665973758092558*^-16, 6}}; |

38 | |

39 | Hdecay`Hdecay[mh_] := If[mh < 500, Max[Interpolation[data, InterpolationOrder->1][mh], 0], interpolation[mh, params]]/;(mh >= 0); |

40 | Hdecay`Hdecay::usage = "usage: Hdecay [mh]"; |

41 | |

42 | End[]; |

43 | Protect[Hdecay]; |

44 | EndPackage[]; |

45 | (* Spectrum calculator for compact HEIDI. For more information, please take * |

46 | * a look at * |

47 | * * |

48 | * "Exploring the golden channel for HEIDI models using an interface between * |

49 | * WHIZARD and FeynRules", N. D. Christensen, C. Duhr, B. Fuks, J. Reuter,* |

50 | * C. Speckner, arXiv:1010.3251 * |

51 | * * |

52 | * Please cite above reference if you use this program. *) |

53 | |

54 | BeginPackage["Heidi`"]; |

55 | Begin["Heidi`p`"]; |

56 | Needs["Hdecay`"]; |

57 | |

58 | (* Initialize the package and clear all caches. *) |

59 | Heidi`InitHeidi[mv_, mmh_, mcs_, mmb_, mg2_, mprec_] := Block[{}, |

60 | v = mv; |

61 | mh = mmh; |

62 | cs = mcs; |

63 | mb = mmb; |

64 | g2 = mg2; |

65 | g = N[Sqrt[g2]]; |

66 | alpha = N[g2 / mb * Coth[mb * Pi / cs]]; |

67 | lambda = N[mh^2 / v^2 / 2]; |

68 | prec = mprec; |

69 | Clear[MassCache, WFCache, WidthCache]; |

70 | If[lambda <= alpha, |

71 | mh = 1.1 * Sqrt[2*alpha] * v; |

72 | Print["WARNING: choosen Higgs mass is to small; using mh " |

73 | <> ToString [mh] <> "GeV instead!"]; |

74 | InitHeidi[v, mh, cs, mb, g2, prec]; |

75 | ]; |

76 | ]; |

77 | |

78 | Heidi`InitHeidi[v_, mh_, cs_, mb_, g2_] := InitHeidi[v, mh, cs, mb, g2, 0.000001]; |

79 | |

80 | Heidi`InitHeidi::usage = "usage: InitHeidi [v, mh, cs, mb, g2, prec] |

81 | v : higgs VeV |

82 | mh : higgs mass |

83 | cs : compactification scale |

84 | mb : bulk mass |

85 | g2 : 5D mixing squared |

86 | prec : precision for the numeric determination of the masses |

87 | (optional; default: 0.000001)"; |

88 | |

89 | |

90 | (* Calculate the nth mass eigenvalue *) |

91 | Heidi`HeidiMass[n_] := Block[{fun, l, r, x, oldx}, |

92 | If[NumericQ[MassCache[n]], |

93 | MassCache[n] |

94 | , |

95 | If[n > 0, |

96 | fun = (mh^2 - mb^2 + 2*g2*v^2/# * Cot[Pi/cs*#] - #^2)&; |

97 | l = (n - 1) * cs; r = n * cs; |

98 | , |

99 | fun = (mb^2 - mh^2 + 2*g2*v^2/# * Coth[Pi/cs*#] - #^2)&; |

100 | l = 0; r = mb; |

101 | ]; |

102 | oldx = l; |

103 | x = (l + r) / 2; |

104 | While[Abs[(x - oldx) / x] > prec, |

105 | oldx = x; |

106 | If[fun[x] > 0, l = x, r = x]; |

107 | x = (l + r) / 2; |

108 | ]; |

109 | MassCache[n] = If[n == 0, Sqrt[mb^2 - N[x]^2], Sqrt[N[x]^2 + mb^2]] |

110 | ] |

111 | ]/;(n >= 0); |

112 | |

113 | Heidi`HeidiMass::usage = "usage: HeidiMass [n] |

114 | n : mode index"; |

115 | |

116 | |

117 | (* Calculate the mth component of the nth wavefunction *) |

118 | Heidi`HeidiWavefunction[n_, m_] := Block[{}, |

119 | If[NumericQ[WFCache[n, m]], |

120 | WFCache[n, m] |

121 | , |

122 | If[m == 0, |

123 | WFCache[n, m] = N[1/Sqrt[ |

124 | 1 + g2*v^2*Pi/cs/(HeidiMass[n]^2 - mb^2) + |

125 | (HeidiMass[n]^2 - mh^2)/2/(HeidiMass[n]^2 - mb^2) + |

126 | (HeidiMass[n]^2 - mh^2)^2 * Pi/4/g2/v^2/cs |

127 | ]] |

128 | , |

129 | WFCache[n, m] = N[HeidiWavefunction[n, 0] * |

130 | 2*g*v*Sqrt[cs/Pi/If[m == 1, 2, 1]] / |

131 | (HeidiMass[n]^2 - mb^2 - (m - 1)^2*cs^2)] |

132 | ] |

133 | ] |

134 | ]/;((n >= 0) && (m >= 0)); |

135 | |

136 | Heidi`HeidiWavefunction::usage = "usage: HeidiWavefunction [n, m] |

137 | n : mode index |

138 | m : wavefunction component index (0 = pre-mixing higgs)"; |

139 | |

140 | |

141 | Heidi`HeidiScalarCoupling[i__] := Block[{}, |

142 | -I*6 * (Times @@ (Heidi`HeidiWavefunction[#, 0]& /@ {i})) |

143 | ]/;((Length[{i}] == 4) && (And @@ ((# >= 0)& /@ {i}))); |

144 | |

145 | Heidi`HeidiScalarCoupling[i__] := Block [{thing}, |

146 | -2*I*v * (Times @@ (Heidi`HeidiWavefunction[#, 0]& /@ {i})) * |

147 | (3*lambda - ((Plus @@ ((HeidiMass[#]^2)& /@ {i})) - 3 * mh^2)/2/v^2) |

148 | ]/;((Length[{i}] == 3) && (And @@ ((# >= 0)& /@ {i}))); |

149 | |

150 | Heidi`HeidiScalarCoupling::usage = "usage: HeidiScalarCoupling [i1, ..., in] |

151 | i1, ..., in : modes meeting at the vertex (n = 3 or n = 4)"; |

152 | |

153 | |

154 | Heidi`HeidiScalarWidth[i_] := Block[{calc}, |

155 | calc[{x_, j_, k_}] := Which[ |

156 | j == i, {x, j, k}, |

157 | (HeidiMass[i] < HeidiMass[j] + HeidiMass[k]) || (k > j), {x, j+1, 0}, |

158 | True, { |

159 | Sqrt[ |

160 | (HeidiMass[i]^2 - (HeidiMass[j] + HeidiMass[k])^2) * |

161 | (HeidiMass[i]^2 - (HeidiMass[j] - HeidiMass[k])^2)] |

162 | /16/Pi/HeidiMass[i]^3 * Abs[HeidiScalarCoupling[i, j, k]]^2 |

163 | /If[j == k, 2, 1] + x, j, k+1} |

164 | ]; |

165 | If[NumericQ[WidthCache[i]], WidthCache[i], WidthCache[i] = FixedPoint[calc, {0, 0, 0}][[1]]] |

166 | ]/;(i >= 0); |

167 | |

168 | Heidi`HeidiScalarWidth::usage = "usage: HeidiScalarWidth [n] |

169 | n : mode index"; |

170 | |

171 | |

172 | Heidi`HeidiSMWidth[i_] := Block[{}, |

173 | Hdecay[HeidiMass[i]] * HeidiWavefunction[i, 0]^2 |

174 | ]/;(i >= 0); |

175 | |

176 | Heidi`HeidiSMWidth::usage = "usage: HeidiSMWidth [n] |

177 | n : mode index"; |

178 | |

179 | |

180 | Heidi`HeidiWidth[i_] := HeidiSMWidth[i] + HeidiScalarWidth[i]; |

181 | |

182 | Heidi`HeidiWidth::usage = "usage: HeidiWidth [n] |

183 | n : mode index"; |

184 | |

185 | End[]; |

186 | Protect[InitHeidi, HeidiMass, HeidiWavefunction, HeidiScalarCoupling, HeidiScalarWidth, |

187 | HeidiSMWidth, HeidiWidth]; |

188 | EndPackage[]; |

189 | (* ************************************************************************************* |

190 | HEIDI Higgs with a compact extra dimension. |

191 | |

192 | The model is intended for use on top of the Standard Model where it replaces the |

193 | Higgs sector. As the theory contains a variable number of modes below the cutoff |

194 | (the masses of which cannot be expressed analytically), the HEIDI parameters have to |

195 | be set before creating the Feynman rules and model files. Those parameters are: |

196 | |

197 | Heidi$v : higgs VeV. Optional, default is the value. |

198 | Heidi$mh : higgs Mass. Optional, default is the SM value |

199 | Heidi$cs : compactification scale |

200 | Heidi$mb : bulk mass |

201 | Heidi$g2 : 5D trilinear coupling squared |

202 | Heidi$cutoff : cutoff scale |

203 | Heidi$nmodes : if Heidi$cutoff is undefined, Heidi$nmodes determines the number of |

204 | modes in the spectrum (starting from index 0) |

205 | |

206 | Masses, widths and couplings are calculated statically. DO NOT CHANGE THOSE OR THE |

207 | ELECTROWEAK PARAMETERS AFTER CREATING THE MODEL. |

208 | |

209 | This model file is a descendant of Claude Duhr's SMScalars model. |

210 | |

211 | *) |

212 | |

213 | |

214 | (* Make sure everything we need is at our disposal *) |

215 | Needs["Heidi`"]; |

216 | Block[{error}, |

217 | error[s_] := (Print["HEIDI error: please set " <> s]; Throw[Null]); |

218 | If[!NumericQ[Heidi$v], error["Heidi$v"]]; |

219 | If[!NumericQ[Heidi$mh], error["Heidi$mh"]]; |

220 | If[!NumericQ[Heidi$cs], error["Heidi$cs"]]; |

221 | If[!NumericQ[Heidi$mb], error["Heidi$mb"]]; |

222 | If[!NumericQ[Heidi$g2], error["Heidi$g2"]]; |

223 | If[FeynmanGauge, |

224 | Print["HEIDI error: the model currently only supports unitarity gauge" |

225 | <> "; please set FeynmanGauge = False."]; |

226 | Throw[Null]; |

227 | ]; |

228 | ]; |

229 | |

230 | (* Init HEIDI *) |

231 | InitHeidi[Heidi$v, Heidi$mh, Heidi$cs, Heidi$mb, Heidi$g2]; |

232 | |

233 | (* Determine the number of modes we have been requested to include *) |

234 | If[NumericQ[Heidi$cutoff], |

235 | Heidi$nmodes = FixedPoint[If[HeidiMass[#] < Heidi$cutoff, # + 1, #]&, 0]; |

236 | ]; |

237 | If[!NumericQ[Heidi$nmodes], |

238 | Print["HEIDI error: please set either Heidi$cutoff or Heidi$nmodes"]; |

239 | Throw[Null]; |

240 | ]; |

241 | |

242 | (* Model metadata *) |

243 | M$ModelName = "HEIDI"; |

244 | M$Information = {Authors -> "C. Speckner", |

245 | Institutions -> "Universitaet Freiburg", |

246 | Emails -> "Christian.Speckner@physik.uni-freiburg.de", |

247 | Date -> "30.07.2010", |

248 | Version -> "0.1", |

249 | URLs -> "None", |

250 | References -> ( |

251 | "" |

252 | <> "\"Exploring the golden channel for HEIDI models using an " |

253 | <> "interface between WHIZARD and FeynRules\", " |

254 | <> "N. D. Christensen, C. Duhr, B. Fuks, J. Reuter, C. Speckner, " |

255 | <> "arXiv:1010.3251") |

256 | }; |

257 | |

258 | (* The flavor index for the HEIDI modes *) |

259 | IndexRange[Index[Heidi]] = Range[Heidi$nmodes]; |

260 | IndexStyle[Heidi, k]; |

261 | |

262 | M$Parameters = { |

263 | (* The Higgs wavefunction is a tensor parameter, the entries of which are * |

264 | * stored numerically as external parameters. *) |

265 | xi == { |

266 | Indices -> {Index[Heidi]}, |

267 | ComplexParameter -> False, |

268 | Value -> Table[Rule[xi[n], HeidiWavefunction[n - 1, 0]], |

269 | {n, 1, Heidi$nmodes}], |

270 | Description -> "Higgs wave function", |

271 | ParameterType -> External, |

272 | AllowSummation -> True |

273 | }, |

274 | (* K factor for the effective ggh coupling *) |

275 | kggh == { |

276 | Value -> 1, |

277 | ParamterType -> External, |

278 | Description -> "ggh K factor" |

279 | } |

280 | }; |

281 | |

282 | |

283 | (* Enter the HEIDI scalars *) |

284 | M$ClassesDescription = { |

285 | S[4] == { |

286 | ClassName -> Hh, |

287 | ClassMembers -> Table[Symbol["Hh" <> ToString[n]], {n, 1, Heidi$nmodes}], |

288 | SelfConjugate -> True, |

289 | Indices -> {Index[Heidi]}, |

290 | FlavorIndex -> Heidi, |

291 | Mass -> Table[{Symbol["mhh" <> ToString[n]], HeidiMass[n - 1]}, {n, 1, Heidi$nmodes}], |

292 | Width -> Table[{Symbol["whh" <> ToString[n]], HeidiWidth[n - 1]}, {n, 1, Heidi$nmodes}], |

293 | PDG -> Table[990000 + n, {n, 1, Heidi$nmodes}] |

294 | } |

295 | } |

296 | |

297 | (* Construct HEIDI Lagrangian *) |

298 | LHEIDI := (LSM /. {muH -> 0, \[Lambda] -> 0}) /. H -> (Hh[n]*xi[n]); |

299 | LHEIDI::usage = "LHEIDI: HEIDI lagrangian"; |

300 | |

301 | (* Optional: the effective ggh_i lagrangian *) |

302 | LHEIDIgg[mode_] := Block[{fun, piece, tt, mm, hh}, |

303 | Print["adding effective scalar-gluon-gluon vertices " <> If[mode == "heavytop", |

304 | "in heavy top limit", "with dynamical loop factor"]]; |

305 | tt[m_] := 4*MT^2 / m^2; |

306 | fun[tau_] := If[mode == "heavytop", 2/3, |

307 | tau * (1 + (1 - tau)* If[NumericalValue[tau] > 1, |

308 | ArcSin[Sqrt[1 / tau]]^2 |

309 | , |

310 | -1/4 * (Log[(1 + Sqrt[1 + tau])/(1 - Sqrt[1 - tau])] |

311 | - I*Pi)^2 |

312 | ]) |

313 | ]; |

314 | mm[n_] := Symbol["mhh" <> ToString[n]]; |

315 | hh[n_] := Symbol["Hh" <> ToString[n]]; |

316 | piece[n_] := |

317 | Sqrt[kggh] * gs^2/32/Pi^2/v * fun[tt[mm[n]]] * xi[n] * |

318 | hh[n] * (del[G[mu, a], nu] - del[G[nu, a], mu])^2; |

319 | Plus @@ (piece /@ Range[Heidi$nmodes]) |

320 | ]; |

321 | LHEIDIgg[] := LHEIDIgg[""]; |

322 | LHEIDIgg::usage = "LHEIDIgg [mode]: HEIDI effective scalar-gluon-gluon couplings |

323 | mode : optional, set to \"heavytop\" to use heavy top limit"; |

324 | |

325 | (* Protect our symbols. *) |

326 | Protect[LHEIDI, LHEIDIgg]; |

327 | |

328 | (* Spit out final warnings. *) |

329 | Print["HEIDI initialized. Please doublecheck that the runtime parametrization of " |

330 | <> "the electroweak sector is consistent with the parameters you used for HEIDI " |

331 | <> "before running any code."]; |