# CHEIDI: Heidi.m

File Heidi.m, 4.7 KB (added by ChristianSpeckner, 8 years ago) |
---|

Line | |
---|---|

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

2 | * a look at * |

3 | * * |

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

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

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

7 | * * |

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

9 | |

10 | BeginPackage["Heidi`"]; |

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

12 | Needs["Hdecay`"]; |

13 | |

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

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

16 | v = mv; |

17 | mh = mmh; |

18 | cs = mcs; |

19 | mb = mmb; |

20 | g2 = mg2; |

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

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

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

24 | prec = mprec; |

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

26 | If[lambda <= alpha, |

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

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

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

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

31 | ]; |

32 | ]; |

33 | |

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

35 | |

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

37 | v : higgs VeV |

38 | mh : higgs mass |

39 | cs : compactification scale |

40 | mb : bulk mass |

41 | g2 : 5D mixing squared |

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

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

44 | |

45 | |

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

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

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

49 | MassCache[n] |

50 | , |

51 | If[n > 0, |

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

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

54 | , |

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

56 | l = 0; r = mb; |

57 | ]; |

58 | oldx = l; |

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

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

61 | oldx = x; |

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

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

64 | ]; |

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

66 | ] |

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

68 | |

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

70 | n : mode index"; |

71 | |

72 | |

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

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

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

76 | WFCache[n, m] |

77 | , |

78 | If[m == 0, |

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

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

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

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

83 | ]] |

84 | , |

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

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

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

88 | ] |

89 | ] |

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

91 | |

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

93 | n : mode index |

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

95 | |

96 | |

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

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

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

100 | |

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

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

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

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

105 | |

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

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

108 | |

109 | |

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

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

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

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

114 | True, { |

115 | Sqrt[ |

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

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

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

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

120 | ]; |

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

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

123 | |

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

125 | n : mode index"; |

126 | |

127 | |

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

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

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

131 | |

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

133 | n : mode index"; |

134 | |

135 | |

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

137 | |

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

139 | n : mode index"; |

140 | |

141 | End[]; |

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

143 | HeidiSMWidth, HeidiWidth]; |

144 | EndPackage[]; |