a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsKigen.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2014 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "HiggsKigen.h"
9 
10 const std::string HiggsKigen::HKvKfgenvars[NHKvKfgenvars] = {
11  "Kw", "Kz", "Kg", "Kga", "Kzga", "Ku", "Kc", "Kt", "Kd", "Ks", "Kb", "Ke", "Kmu", "Ktau", "KH", "BrHinv", "BrHexo",
12  "eggFint","eggFpar","ettHint","ettHpar",
13  "eVBFint","eVBFpar","eWHint","eWHpar","eZHint","eZHpar",
14  "eeeWBFint","eeeWBFpar","eeeZHint","eeeZHpar","eeettHint","eeettHpar",
15  "eepWBFint","eepWBFpar","eepZBFint","eepZBFpar",
16  "eHggint","eHggpar","eHWWint","eHWWpar","eHZZint","eHZZpar","eHZgaint","eHZgapar",
17  "eHgagaint","eHgagapar","eHmumuint","eHmumupar","eHtautauint","eHtautaupar",
18  "eHccint","eHccpar","eHbbint","eHbbpar",
19  "eggFHgaga","eggFHZga","eggFHZZ","eggFHWW","eggFHtautau","eggFHbb","eggFHmumu",
20  "eVBFHgaga","eVBFHZga","eVBFHZZ","eVBFHWW","eVBFHtautau","eVBFHbb","eVBFHmumu",
21  "eWHgaga","eWHZga","eWHZZ","eWHWW","eWHtautau","eWHbb","eWHmumu",
22  "eZHgaga","eZHZga","eZHZZ","eZHWW","eZHtautau","eZHbb","eZHmumu",
23  "ettHgaga","ettHZga","ettHZZ","ettHWW","ettHtautau","ettHbb","ettHmumu",
24  "eVBFHinv","eVHinv"
25 };
26 
27 HiggsKigen::HiggsKigen()
28 : NPbase()
29 {
30  FlagKiLoop = true;
31  FlagCustodial = false;
32  FlagUniversalKf = false;
33  FlagUniversalK = false;
34  FlagUseKH = false;
35 
36  ModelParamMap.insert(std::make_pair("Kw", std::cref(Kw)));
37  ModelParamMap.insert(std::make_pair("Kz", std::cref(Kz)));
38  ModelParamMap.insert(std::make_pair("Kg", std::cref(Kg)));
39  ModelParamMap.insert(std::make_pair("Kga", std::cref(Kga)));
40  ModelParamMap.insert(std::make_pair("Kzga", std::cref(Kzga)));
41  ModelParamMap.insert(std::make_pair("Ku", std::cref(Ku)));
42  ModelParamMap.insert(std::make_pair("Kc", std::cref(Kc)));
43  ModelParamMap.insert(std::make_pair("Kt", std::cref(Kt)));
44  ModelParamMap.insert(std::make_pair("Kd", std::cref(Kd)));
45  ModelParamMap.insert(std::make_pair("Ks", std::cref(Ks)));
46  ModelParamMap.insert(std::make_pair("Kb", std::cref(Kb)));
47  ModelParamMap.insert(std::make_pair("Ke", std::cref(Ke)));
48  ModelParamMap.insert(std::make_pair("Kmu", std::cref(Kmu)));
49  ModelParamMap.insert(std::make_pair("Ktau", std::cref(Ktau)));
50  ModelParamMap.insert(std::make_pair("KH", std::cref(KH)));
51  ModelParamMap.insert(std::make_pair("BrHinv", std::cref(BrHinv)));
52  ModelParamMap.insert(std::make_pair("BrHexo", std::cref(BrHexo)));
53  ModelParamMap.insert(std::make_pair("eggFint", std::cref(eggFint)));
54  ModelParamMap.insert(std::make_pair("eggFpar", std::cref(eggFpar)));
55  ModelParamMap.insert(std::make_pair("ettHint", std::cref(ettHint)));
56  ModelParamMap.insert(std::make_pair("ettHpar", std::cref(ettHpar)));
57  ModelParamMap.insert(std::make_pair("eVBFint", std::cref(eVBFint)));
58  ModelParamMap.insert(std::make_pair("eVBFpar", std::cref(eVBFpar)));
59  ModelParamMap.insert(std::make_pair("eWHint", std::cref(eWHint)));
60  ModelParamMap.insert(std::make_pair("eWHpar", std::cref(eWHpar)));
61  ModelParamMap.insert(std::make_pair("eZHint", std::cref(eZHint)));
62  ModelParamMap.insert(std::make_pair("eZHpar", std::cref(eZHpar)));
63  ModelParamMap.insert(std::make_pair("eeeWBFint", std::cref(eeeWBFint)));
64  ModelParamMap.insert(std::make_pair("eeeWBFpar", std::cref(eeeWBFpar)));
65  ModelParamMap.insert(std::make_pair("eeeZHint", std::cref(eeeZHint)));
66  ModelParamMap.insert(std::make_pair("eeeZHpar", std::cref(eeeZHpar)));
67  ModelParamMap.insert(std::make_pair("eeettHint", std::cref(eeettHint)));
68  ModelParamMap.insert(std::make_pair("eeettHpar", std::cref(eeettHpar)));
69  ModelParamMap.insert(std::make_pair("eepWBFint", std::cref(eepWBFint)));
70  ModelParamMap.insert(std::make_pair("eepWBFpar", std::cref(eepWBFpar)));
71  ModelParamMap.insert(std::make_pair("eepZBFint", std::cref(eepZBFint)));
72  ModelParamMap.insert(std::make_pair("eepZBFpar", std::cref(eepZBFpar)));
73  ModelParamMap.insert(std::make_pair("eHggint", std::cref(eHggint)));
74  ModelParamMap.insert(std::make_pair("eHggpar", std::cref(eHggpar)));
75  ModelParamMap.insert(std::make_pair("eHWWint", std::cref(eHWWint)));
76  ModelParamMap.insert(std::make_pair("eHWWpar", std::cref(eHWWpar)));
77  ModelParamMap.insert(std::make_pair("eHZZint", std::cref(eHZZint)));
78  ModelParamMap.insert(std::make_pair("eHZZpar", std::cref(eHZZpar)));
79  ModelParamMap.insert(std::make_pair("eHZgaint", std::cref(eHZgaint)));
80  ModelParamMap.insert(std::make_pair("eHZgapar", std::cref(eHZgapar)));
81  ModelParamMap.insert(std::make_pair("eHgagaint", std::cref(eHgagaint)));
82  ModelParamMap.insert(std::make_pair("eHgagapar", std::cref(eHgagapar)));
83  ModelParamMap.insert(std::make_pair("eHmumuint", std::cref(eHmumuint)));
84  ModelParamMap.insert(std::make_pair("eHmumupar", std::cref(eHmumupar)));
85  ModelParamMap.insert(std::make_pair("eHtautauint", std::cref(eHtautauint)));
86  ModelParamMap.insert(std::make_pair("eHtautaupar", std::cref(eHtautaupar)));
87  ModelParamMap.insert(std::make_pair("eHccint", std::cref(eHccint)));
88  ModelParamMap.insert(std::make_pair("eHccpar", std::cref(eHccpar)));
89  ModelParamMap.insert(std::make_pair("eHbbint", std::cref(eHbbint)));
90  ModelParamMap.insert(std::make_pair("eHbbpar", std::cref(eHbbpar)));
91  ModelParamMap.insert(std::make_pair("eggFHgaga", std::cref(eggFHgaga)));
92  ModelParamMap.insert(std::make_pair("eggFHZga", std::cref(eggFHZga)));
93  ModelParamMap.insert(std::make_pair("eggFHZZ", std::cref(eggFHZZ)));
94  ModelParamMap.insert(std::make_pair("eggFHWW", std::cref(eggFHWW)));
95  ModelParamMap.insert(std::make_pair("eggFHtautau", std::cref(eggFHtautau)));
96  ModelParamMap.insert(std::make_pair("eggFHbb", std::cref(eggFHbb)));
97  ModelParamMap.insert(std::make_pair("eggFHmumu", std::cref(eggFHmumu)));
98  ModelParamMap.insert(std::make_pair("eVBFHgaga", std::cref(eVBFHgaga)));
99  ModelParamMap.insert(std::make_pair("eVBFHZga", std::cref(eVBFHZga)));
100  ModelParamMap.insert(std::make_pair("eVBFHZZ", std::cref(eVBFHZZ)));
101  ModelParamMap.insert(std::make_pair("eVBFHWW", std::cref(eVBFHWW)));
102  ModelParamMap.insert(std::make_pair("eVBFHtautau", std::cref(eVBFHtautau)));
103  ModelParamMap.insert(std::make_pair("eVBFHbb", std::cref(eVBFHbb)));
104  ModelParamMap.insert(std::make_pair("eVBFHmumu", std::cref(eVBFHmumu)));
105  ModelParamMap.insert(std::make_pair("eWHgaga", std::cref(eWHgaga)));
106  ModelParamMap.insert(std::make_pair("eWHZga", std::cref(eWHZga)));
107  ModelParamMap.insert(std::make_pair("eWHZZ", std::cref(eWHZZ)));
108  ModelParamMap.insert(std::make_pair("eWHWW", std::cref(eWHWW)));
109  ModelParamMap.insert(std::make_pair("eWHtautau", std::cref(eWHtautau)));
110  ModelParamMap.insert(std::make_pair("eWHbb", std::cref(eWHbb)));
111  ModelParamMap.insert(std::make_pair("eWHmumu", std::cref(eWHmumu)));
112  ModelParamMap.insert(std::make_pair("eZHgaga", std::cref(eZHgaga)));
113  ModelParamMap.insert(std::make_pair("eZHZga", std::cref(eZHZga)));
114  ModelParamMap.insert(std::make_pair("eZHZZ", std::cref(eZHZZ)));
115  ModelParamMap.insert(std::make_pair("eZHWW", std::cref(eZHWW)));
116  ModelParamMap.insert(std::make_pair("eZHtautau", std::cref(eZHtautau)));
117  ModelParamMap.insert(std::make_pair("eZHbb", std::cref(eZHbb)));
118  ModelParamMap.insert(std::make_pair("eZHmumu", std::cref(eZHmumu)));
119  ModelParamMap.insert(std::make_pair("ettHgaga", std::cref(ettHgaga)));
120  ModelParamMap.insert(std::make_pair("ettHZga", std::cref(ettHZga)));
121  ModelParamMap.insert(std::make_pair("ettHZZ", std::cref(ettHZZ)));
122  ModelParamMap.insert(std::make_pair("ettHWW", std::cref(ettHWW)));
123  ModelParamMap.insert(std::make_pair("ettHtautau", std::cref(ettHtautau)));
124  ModelParamMap.insert(std::make_pair("ettHbb", std::cref(ettHbb)));
125  ModelParamMap.insert(std::make_pair("ettHmumu", std::cref(ettHmumu)));
126  ModelParamMap.insert(std::make_pair("eVBFHinv", std::cref(eVBFHinv)));
127  ModelParamMap.insert(std::make_pair("eVHinv", std::cref(eVHinv)));
128 }
129 
130 bool HiggsKigen::PostUpdate()
131 {
132  if (!NPbase::PostUpdate()) return (false);
133 
134 // Check first the flags that control the values of the parameters
135 
136  if (FlagCustodial) {
137 // Assign to all Kz the value of Kw
138  Kz = Kw;
139  }
140 
141  if (FlagUniversalKf) {
142 // Assign to all Kf the value of Kt
143  Ku = Kt;
144  Kc = Kt;
145  Kd = Kt;
146  Ks = Kt;
147  Kb = Kt;
148  Ke = Kt;
149  Kmu = Kt;
150  Ktau = Kt;
151  }
152 
153  if (FlagUniversalK) {
154 // Assign to all K the value of Kt
155  Kz = Kt;
156  Kw = Kt;
157 
158  Ku = Kt;
159  Kc = Kt;
160  Kd = Kt;
161  Ks = Kt;
162  Kb = Kt;
163  Ke = Kt;
164  Kmu = Kt;
165  Ktau = Kt;
166 
167 // If the following are given by modifications of SM loops only they will be replaced below
168  Kg = Kt;
169  Kga = Kt;
170  Kzga = Kt;
171  }
172 
173 // Calculation of some quantities repeteadly used in the code
174 
175 // Then the flag to add the values of the loops to the cache
176 
177  if (!FlagKiLoop) {
178  Kg = computeKgLoop();
179  Kga = computeKgagaLoop();
180  Kzga = computeKZgaLoop();
181  }
182 
183 // Ratio of the total Higgs width with respect to SM and Exotic BR
184  if (FlagUseKH) {
185  GammaHTotR = KH*KH;
186  GammaHTotSMR = computeGammaTotalSMRatio();
187 
188  GammaHTotnoER = KH*KH;
189  GammaHTotSMnoER = computeGammaTotalSMnoErrorRatio();
190 
191  // Compute BrHexo from KH
192  BrHexo = 1.0 - BrHinv - GammaHTotSMR/GammaHTotR;
193 
194  // BRHinv is positive by definition and the bound is controlled by the corresponding parameter.
195  // The exotic must be in [0,1]. Demand that 0<BrHexo<1.
196  // Otherwise, exclude the point from likelihood by assigning a nan to all parameters
197  if ( (BrHexo > 1.0) || (BrHexo < 0.0) ) {
198 
199  GammaHTotR = std::numeric_limits<double>::quiet_NaN();
200 
201  Kw = std::numeric_limits<double>::quiet_NaN();
202  Kz = std::numeric_limits<double>::quiet_NaN();
203  Kg = std::numeric_limits<double>::quiet_NaN();
204  Kga = std::numeric_limits<double>::quiet_NaN();
205  Kzga = std::numeric_limits<double>::quiet_NaN();
206  Ku = std::numeric_limits<double>::quiet_NaN();
207  Kc = std::numeric_limits<double>::quiet_NaN();
208  Kt = std::numeric_limits<double>::quiet_NaN();
209  Kd = std::numeric_limits<double>::quiet_NaN();
210  Ks = std::numeric_limits<double>::quiet_NaN();
211  Kb = std::numeric_limits<double>::quiet_NaN();
212  Ke = std::numeric_limits<double>::quiet_NaN();
213  Kmu = std::numeric_limits<double>::quiet_NaN();
214  Ktau = std::numeric_limits<double>::quiet_NaN();
215  KH = std::numeric_limits<double>::quiet_NaN();
216 
217  BrHinv = std::numeric_limits<double>::quiet_NaN();
218  BrHexo = std::numeric_limits<double>::quiet_NaN();
219  }
220 
221  } else {
222  GammaHTotR = computeGammaTotalRatio();
223  GammaHTotSMR = computeGammaTotalSMRatio();
224 
225  GammaHTotnoER = computeGammaTotalnoErrorRatio();
226  GammaHTotSMnoER = computeGammaTotalSMnoErrorRatio();
227  }
228 
229  // The total theory error in the H width
230  eHwidth = ( GammaHTotR - GammaHTotnoER ) / GammaHTotnoER;
231 
232  return (true);
233 }
234 
235 void HiggsKigen::setParameter(const std::string name, const double& value)
236 {
237  if (name.compare("Kw") == 0) {
238  Kw = value;
239  } else if (name.compare("Kz") == 0) {
240  Kz = value;
241  } else if (name.compare("Kg") == 0) {
242  Kg = value;
243  } else if (name.compare("Kga") == 0) {
244  Kga = value;
245  } else if (name.compare("Kzga") == 0) {
246  Kzga = value;
247  } else if (name.compare("Ku") == 0) {
248  Ku = value;
249  } else if (name.compare("Kc") == 0) {
250  Kc = value;
251  } else if (name.compare("Kt") == 0) {
252  Kt = value;
253  } else if (name.compare("Kd") == 0) {
254  Kd = value;
255  } else if (name.compare("Ks") == 0) {
256  Ks = value;
257  } else if (name.compare("Kb") == 0) {
258  Kb = value;
259  } else if (name.compare("Ke") == 0) {
260  Ke = value;
261  } else if (name.compare("Kmu") == 0) {
262  Kmu = value;
263  } else if (name.compare("Ktau") == 0) {
264  Ktau = value;
265  } else if (name.compare("KH") == 0) {
266  KH = value;
267  } else if (name.compare("BrHinv") == 0) {
268 // Always positive
269  BrHinv = fabs(value);
270  } else if (name.compare("BrHexo") == 0) {
271 // Always positive
272  BrHexo = fabs(value);
273  } else if (name.compare("eggFint") == 0) {
274  eggFint = value;
275  } else if (name.compare("eggFpar") == 0) {
276  eggFpar = value;
277  } else if (name.compare("ettHint") == 0) {
278  ettHint = value;
279  } else if (name.compare("ettHpar") == 0) {
280  ettHpar = value;
281  } else if (name.compare("eVBFint") == 0) {
282  eVBFint = value;
283  } else if (name.compare("eVBFpar") == 0) {
284  eVBFpar = value;
285  } else if (name.compare("eWHint") == 0) {
286  eWHint = value;
287  } else if (name.compare("eWHpar") == 0) {
288  eWHpar = value;
289  } else if (name.compare("eZHint") == 0) {
290  eZHint = value;
291  } else if (name.compare("eZHpar") == 0) {
292  eZHpar = value;
293  } else if (name.compare("eeeWBFint") == 0) {
294  eeeWBFint = value;
295  } else if (name.compare("eeeWBFpar") == 0) {
296  eeeWBFpar = value;
297  } else if (name.compare("eeeZHint") == 0) {
298  eeeZHint = value;
299  } else if (name.compare("eeeZHpar") == 0) {
300  eeeZHpar = value;
301  } else if (name.compare("eeettHint") == 0) {
302  eeettHint = value;
303  } else if (name.compare("eeettHpar") == 0) {
304  eeettHpar = value;
305  } else if (name.compare("eepWBFint") == 0) {
306  eepWBFint = value;
307  } else if (name.compare("eepWBFpar") == 0) {
308  eepWBFpar = value;
309  } else if (name.compare("eepZBFint") == 0) {
310  eepZBFint = value;
311  } else if (name.compare("eepZBFpar") == 0) {
312  eepZBFpar = value;
313  } else if (name.compare("eHggint") == 0) {
314  eHggint = value;
315  } else if (name.compare("eHggpar") == 0) {
316  eHggpar = value;
317  } else if (name.compare("eHWWint") == 0) {
318  eHWWint = value;
319  } else if (name.compare("eHWWpar") == 0) {
320  eHWWpar = value;
321  } else if (name.compare("eHZZint") == 0) {
322  eHZZint = value;
323  } else if (name.compare("eHZZpar") == 0) {
324  eHZZpar = value;
325  } else if (name.compare("eHZgaint") == 0) {
326  eHZgaint = value;
327  } else if (name.compare("eHZgapar") == 0) {
328  eHZgapar = value;
329  } else if (name.compare("eHgagaint") == 0) {
330  eHgagaint = value;
331  } else if (name.compare("eHgagapar") == 0) {
332  eHgagapar = value;
333  } else if (name.compare("eHmumuint") == 0) {
334  eHmumuint = value;
335  } else if (name.compare("eHmumupar") == 0) {
336  eHmumupar = value;
337  } else if (name.compare("eHtautauint") == 0) {
338  eHtautauint = value;
339  } else if (name.compare("eHtautaupar") == 0) {
340  eHtautaupar = value;
341  } else if (name.compare("eHccint") == 0) {
342  eHccint = value;
343  } else if (name.compare("eHccpar") == 0) {
344  eHccpar = value;
345  } else if (name.compare("eHbbint") == 0) {
346  eHbbint = value;
347  } else if (name.compare("eHbbpar") == 0) {
348  eHbbpar = value;
349  } else if (name.compare("eggFHgaga") == 0) {
350  eggFHgaga = value;
351  } else if (name.compare("eggFHZga") == 0) {
352  eggFHZga = value;
353  } else if (name.compare("eggFHZZ") == 0) {
354  eggFHZZ = value;
355  } else if (name.compare("eggFHWW") == 0) {
356  eggFHWW = value;
357  } else if (name.compare("eggFHtautau") == 0) {
358  eggFHtautau = value;
359  } else if (name.compare("eggFHbb") == 0) {
360  eggFHbb = value;
361  } else if (name.compare("eggFHmumu") == 0) {
362  eggFHmumu = value;
363  } else if (name.compare("eVBFHgaga") == 0) {
364  eVBFHgaga = value;
365  } else if (name.compare("eVBFHZga") == 0) {
366  eVBFHZga = value;
367  } else if (name.compare("eVBFHZZ") == 0) {
368  eVBFHZZ = value;
369  } else if (name.compare("eVBFHWW") == 0) {
370  eVBFHWW = value;
371  } else if (name.compare("eVBFHtautau") == 0) {
372  eVBFHtautau = value;
373  } else if (name.compare("eVBFHbb") == 0) {
374  eVBFHbb = value;
375  } else if (name.compare("eVBFHmumu") == 0) {
376  eVBFHmumu = value;
377  } else if (name.compare("eWHgaga") == 0) {
378  eWHgaga = value;
379  } else if (name.compare("eWHZga") == 0) {
380  eWHZga = value;
381  } else if (name.compare("eWHZZ") == 0) {
382  eWHZZ = value;
383  } else if (name.compare("eWHWW") == 0) {
384  eWHWW = value;
385  } else if (name.compare("eWHtautau") == 0) {
386  eWHtautau = value;
387  } else if (name.compare("eWHbb") == 0) {
388  eWHbb = value;
389  } else if (name.compare("eWHmumu") == 0) {
390  eWHmumu = value;
391  } else if (name.compare("eZHgaga") == 0) {
392  eZHgaga = value;
393  } else if (name.compare("eZHZga") == 0) {
394  eZHZga = value;
395  } else if (name.compare("eZHZZ") == 0) {
396  eZHZZ = value;
397  } else if (name.compare("eZHWW") == 0) {
398  eZHWW = value;
399  } else if (name.compare("eZHtautau") == 0) {
400  eZHtautau = value;
401  } else if (name.compare("eZHbb") == 0) {
402  eZHbb = value;
403  } else if (name.compare("eZHmumu") == 0) {
404  eZHmumu = value;
405  } else if (name.compare("ettHgaga") == 0) {
406  ettHgaga = value;
407  } else if (name.compare("ettHZga") == 0) {
408  ettHZga = value;
409  } else if (name.compare("ettHZZ") == 0) {
410  ettHZZ = value;
411  } else if (name.compare("ettHWW") == 0) {
412  ettHWW = value;
413  } else if (name.compare("ettHtautau") == 0) {
414  ettHtautau = value;
415  } else if (name.compare("ettHbb") == 0) {
416  ettHbb = value;
417  } else if (name.compare("ettHmumu") == 0) {
418  ettHmumu = value;
419  } else if (name.compare("eVBFHinv") == 0) {
420  eVBFHinv = value;
421  } else if (name.compare("eVHinv") == 0) {
422  eVHinv = value;
423  } else
424  NPbase::setParameter(name, value);
425 }
426 
427 bool HiggsKigen::CheckParameters(const std::map<std::string, double>& DPars)
428 {
429  for (int i = 0; i < NHKvKfgenvars; i++) {
430  if (DPars.find(HKvKfgenvars[i]) == DPars.end()) {
431  std::cout << "ERROR: missing mandatory HiggsKigen parameter " << HKvKfgenvars[i] << std::endl;
432  raiseMissingModelParameterCount();
433  addMissingModelParameter(HKvKfgenvars[i]);
434  }
435  }
436  return (NPbase::CheckParameters(DPars));
437 }
438 
439 bool HiggsKigen::setFlag(const std::string name, const bool value)
440 {
441  bool res = false;
442  if (name.compare("KiLoop") == 0) {
443  FlagKiLoop = value;
444  res = true;
445  } else if (name.compare("Custodial") == 0) {
446  FlagCustodial = value;
447  res = true;
448  } else if (name.compare("UniversalKf") == 0) {
449  FlagUniversalKf = value;
450  res = true;
451  } else if (name.compare("UniversalK") == 0) {
452  FlagUniversalK = value;
453  res = true;
454  } else if (name.compare("UseKH") == 0) {
455  FlagUseKH = value;
456  res = true;
457  } else
458  res = NPbase::setFlag(name, value);
459 
460  return (res);
461 }
462 
464 
465 double HiggsKigen::obliqueS() const
466 {
467  if (FlagCustodial) {
468  double Lambda, Kv;
469 
470  Kv=Kw;
471 
472  if (fabs(1.0 - Kv * Kv) < pow(10.0, -32.0))
473  Lambda = pow(10.0, 19.0);
474  else
475  Lambda = 4.0 * M_PI * v() / sqrt(fabs(1.0 - Kv * Kv));
476 
477  return ( 1.0 / 12.0 / M_PI * (1.0 - Kv * Kv) * log(Lambda * Lambda / mHl / mHl));
478 
479  } else {
480  return 0.0;
481  }
482 }
483 
484 double HiggsKigen::obliqueT() const
485 {
486  if (FlagCustodial) {
487  double Lambda, Kv;
488  double cW2_SM = trueSM.cW2();
489 
490  Kv=Kw;
491 
492  if (fabs(1.0 - Kv * Kv) < pow(10.0, -32.0))
493  Lambda = pow(10.0, 19.0);
494  else
495  Lambda = 4.0 * M_PI * v() / sqrt(fabs(1.0 - Kv * Kv));
496 
497  return ( -3.0 / 16.0 / M_PI / cW2_SM * (1.0 - Kv * Kv) * log(Lambda * Lambda / mHl / mHl));
498 
499  } else {
500  return 0.0;
501  }
502 }
503 
504 double HiggsKigen::obliqueU() const
505 {
506  return 0.0;
507 }
508 
510 
511 double HiggsKigen::muggH(const double sqrt_s) const
512 {
513  double mu = 1.0;
514  mu = (computeKg() * computeKg());
515  return (mu*(1.0 + eggFint + eggFpar));
516 }
517 
518 double HiggsKigen::muVBF(const double sqrt_s) const
519 {
520  double mu = 1.0;
521  double sigmaWF_SM = trueSM.computeSigmaWF(sqrt_s);
522  double sigmaZF_SM = trueSM.computeSigmaZF(sqrt_s);
523  double sigmaZWF_SM = trueSM.computeSigmaZWF(sqrt_s);
524  mu = (computeKW() * computeKW() * sigmaWF_SM
525  + computeKZ() * computeKZ() * sigmaZF_SM
526  + computeKW() * computeKZ() * sigmaZWF_SM)
527  / (sigmaWF_SM + sigmaZF_SM + sigmaZWF_SM);
528  return (mu*(1.0 + eVBFint + eVBFpar));
529 }
530 
531 double HiggsKigen::muVBFgamma(const double sqrt_s) const
532 {
533  // Assume photon comes from the internal W lines -> no ZBF
534  double mu = 1.0;
535  mu = (computeKW() * computeKW());
536  return (mu*(1.0 + eVBFint + eVBFpar));
537 }
538 
539 double HiggsKigen::mueeWBF(const double sqrt_s) const
540 {
541  double mu = 1.0;
542  mu = (computeKW() * computeKW());
543  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
544 }
545 
546 double HiggsKigen::mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
547 {
548  double mu = 1.0;
549  mu = (computeKW() * computeKW());
550  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
551 }
552 
553 double HiggsKigen::mueeHvv(const double sqrt_s) const
554 {
555 // In this model we neglect the contributions from HZ->vv with off-shell Z
556 // Dependence is exact if Custodial symmetry option is on
557  double mu = 1.0;
558  mu = (computeKW() * computeKW());
559  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
560 }
561 
562 double HiggsKigen::mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
563 {
564 // In this model we neglect the contributions from HZ->vv with off-shell Z
565 // Dependence is exact if Custodial symmetry option is on
566  double mu = 1.0;
567  mu = (computeKW() * computeKW());
568  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
569 }
570 
571 double HiggsKigen::mueeZBF(const double sqrt_s) const
572 {
573  double mu = 1.0;
574  mu = (computeKZ() * computeKZ());
575  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
576 }
577 
578 double HiggsKigen::mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
579 {
580  double mu = 1.0;
581  mu = (computeKZ() * computeKZ());
582  return (mu*(1.0 + eeeWBFint + eeeWBFpar));
583 }
584 
585 double HiggsKigen::muepWBF(const double sqrt_s) const
586 {
587  double mu = 1.0;
588  mu = (computeKW() * computeKW());
589  return (mu*(1.0 + eepWBFint + eepWBFpar));
590 }
591 
592 double HiggsKigen::muepZBF(const double sqrt_s) const
593 {
594  double mu = 1.0;
595  mu = (computeKZ() * computeKZ());
596  return (mu*(1.0 + eepZBFint + eepZBFpar));
597 }
598 
599 double HiggsKigen::muWH(const double sqrt_s) const
600 {
601  double mu = 1.0;
602  mu = (computeKW() * computeKW());
603  return (mu*(1.0 + eWHint + eWHpar));
604 }
605 
606 double HiggsKigen::muZH(const double sqrt_s) const
607 {
608  double mu = 1.0;
609  mu = (computeKZ() * computeKZ());
610  return (mu*(1.0 + eZHint + eZHpar));
611 }
612 
613 double HiggsKigen::mueeZH(const double sqrt_s) const
614 {
615  double mu = 1.0;
616  mu = (computeKZ() * computeKZ());
617  return (mu*(1.0 + eeeZHint + eeeZHpar));
618 }
619 
620 double HiggsKigen::mueeZllH(const double sqrt_s) const
621 {
622  double mu = 1.0;
623  mu = (computeKZ() * computeKZ());
624  return (mu*(1.0 + eeeZHint + eeeZHpar));
625 }
626 
627 double HiggsKigen::mueeZqqH(const double sqrt_s) const
628 {
629  double mu = 1.0;
630  mu = (computeKZ() * computeKZ());
631  return (mu*(1.0 + eeeZHint + eeeZHpar));
632 }
633 
634 double HiggsKigen::mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
635 {
636  double mu = 1.0;
637  mu = (computeKZ() * computeKZ());
638  return (mu*(1.0 + eeeZHint + eeeZHpar));
639 }
640 
641 double HiggsKigen::mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
642 {
643  double mu = 1.0;
644  mu = (computeKZ() * computeKZ());
645  return (mu*(1.0 + eeeZHint + eeeZHpar));
646 }
647 
648 double HiggsKigen::mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
649 {
650  double mu = 1.0;
651  mu = (computeKZ() * computeKZ());
652  return (mu*(1.0 + eeeZHint + eeeZHpar));
653 }
654 
655 double HiggsKigen::muVH(const double sqrt_s) const
656 {
657  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
658  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
659  return ((computeKW() * computeKW()*(1.0 + eWHint + eWHpar) * sigmaWH_SM
660  + computeKZ() * computeKZ()*(1.0 + eZHint + eZHpar) * sigmaZH_SM)
661  / (sigmaWH_SM + sigmaZH_SM));
662 }
663 
664 double HiggsKigen::muVBFpVH(const double sqrt_s) const
665 {
666  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
667  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
668  double sigmaWF_SM = trueSM.computeSigmaWF(sqrt_s);
669  double sigmaZF_SM = trueSM.computeSigmaZF(sqrt_s);
670  double sigmaZWF_SM = trueSM.computeSigmaZWF(sqrt_s);
671  double sigmaVBF_SM = sigmaWF_SM + sigmaZF_SM + sigmaZWF_SM;
672 
673  double sigmaWH = muWH(sqrt_s) * sigmaWH_SM;
674  double sigmaZH = muZH(sqrt_s) * sigmaZH_SM;
675  double sigmaVBF = muVBF(sqrt_s) * sigmaVBF_SM;
676 
677  return ((sigmaWH + sigmaZH + sigmaVBF) / (sigmaWH_SM + sigmaZH_SM + sigmaVBF_SM));
678 }
679 
680 double HiggsKigen::muttH(const double sqrt_s) const
681 {
682  double mu = 1.0;
683  mu = (computeKt() * computeKt());
684  return (mu*(1.0 + ettHint + ettHpar));
685 }
686 
687 double HiggsKigen::mutHq(const double sqrt_s) const
688 {
689  double mu = 1.0;
690  double Kt = computeKt();
691  double Kw = computeKW();
692 
693 // From ATLAS parametrization of the K-framework (at 14 TeV?)
694  mu = 2.63 * Kt * Kt + 3.58 * Kw * Kw - 5.21 * Kt * Kw;
695 
696  return mu;
697 }
698 
699 double HiggsKigen::muggHpttH(const double sqrt_s) const
700 {
701  double sigmaggH_SM = trueSM.computeSigmaggH(sqrt_s);
702  double sigmattH_SM = trueSM.computeSigmattH(sqrt_s);
703 
704  double sigmaggH = muggH(sqrt_s) * sigmaggH_SM;
705  double sigmattH = muttH(sqrt_s) * sigmattH_SM;
706 
707  return ((sigmaggH + sigmattH) / (sigmaggH_SM + sigmattH_SM));
708 }
709 
710 double HiggsKigen::mueettH(const double sqrt_s) const
711 {
712  double mu = 1.0;
713  mu = (computeKt() * computeKt());
714  return (mu*(1.0 + eeettHint + eeettHpar));
715 }
716 
717 double HiggsKigen::mummH(const double sqrt_s) const
718 {
719  double mu = 1.0;
720  mu = (computeKmu() * computeKmu());
721  return mu;
722 }
723 
724 double HiggsKigen::mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
725 {
726  double mu = 1.0;
727  mu = (computeKt() * computeKt());
728  return (mu*(1.0 + eeettHint + eeettHpar));
729 }
730 
731 double HiggsKigen::BrHggRatio() const
732 {
733  double Br = 1.0;
734  Br = (computeKg() * computeKg() / GammaHTotR);
735  return (Br * (1.0 + eHggint + eHggpar));
736 }
737 
738 double HiggsKigen::BrHWWRatio() const
739 {
740  double Br = 1.0;
741  Br = (computeKW() * computeKW() / GammaHTotR);
742  return (Br * (1.0 + eHWWint + eHWWpar));
743 }
744 
745 double HiggsKigen::BrHWW2l2vRatio() const
746 {
747  return BrHWWRatio();
748 }
749 
750 double HiggsKigen::BrHZZRatio() const
751 {
752  double Br = 1.0;
753  Br = (computeKZ() * computeKZ() / GammaHTotR);
754  return (Br * (1.0 + eHZZint + eHZZpar));
755 }
756 
757 double HiggsKigen::BrHZZ4lRatio() const
758 {
759  return BrHZZRatio();
760 }
761 
762 double HiggsKigen::BrHZZ4eRatio() const
763 {
764  return BrHZZRatio();
765 }
766 
767 double HiggsKigen::BrHZZ2e2muRatio() const
768 {
769  return BrHZZRatio();
770 }
771 
772 double HiggsKigen::BrHZZ4muRatio() const
773 {
774  return BrHZZRatio();
775 }
776 
777 double HiggsKigen::BrHZgaRatio() const
778 {
779  double Br = 1.0;
780  Br = (computeKZga() * computeKZga() / GammaHTotR);
781  return (Br * (1.0 + eHZgaint + eHZgapar));
782 }
783 
784 double HiggsKigen::BrHZgallRatio() const
785 {
786  return BrHZgaRatio();
787 }
788 
789 double HiggsKigen::BrHZgaeeRatio() const
790 {
791  return BrHZgaRatio();
792 }
793 
794 double HiggsKigen::BrHZgamumuRatio() const
795 {
796  return BrHZgaRatio();
797 }
798 
799 double HiggsKigen::BrHgagaRatio() const
800 {
801  double Br = 1.0;
802  Br = (computeKgaga() * computeKgaga() / GammaHTotR);
803  return (Br * (1.0 + eHgagaint + eHgagapar));
804 }
805 
806 double HiggsKigen::BrHmumuRatio() const
807 {
808  double Br = 1.0;
809  Br = (computeKmu() * computeKmu() / GammaHTotR);
810  return (Br * (1.0 + eHmumuint + eHmumupar));
811 }
812 
813 double HiggsKigen::BrHtautauRatio() const
814 {
815  double Br = 1.0;
816  Br = (computeKtau() * computeKtau() / GammaHTotR);
817  return (Br * (1.0 + eHtautauint + eHtautaupar));
818 }
819 
820 double HiggsKigen::BrHccRatio() const
821 {
822  double Br = 1.0;
823  Br = (computeKc() * computeKc() / GammaHTotR);
824  return (Br * (1.0 + eHccint + eHccpar));
825 }
826 
827 double HiggsKigen::BrHbbRatio() const
828 {
829  double Br = 1.0;
830  Br = (computeKb() * computeKb() / GammaHTotR);
831  return (Br * (1.0 + eHbbint + eHbbpar));
832 }
833 
834 double HiggsKigen::muttHZbbboost(const double sqrt_s) const
835 {
836  return computeKt() * computeKt() * computeKb() * computeKb() / GammaHTotR;
837 
838 }
839 
840 
841 double HiggsKigen::muggHgaga(const double sqrt_s) const
842 {
843  return muggH(sqrt_s)*BrHgagaRatio();
844 }
845 
846 double HiggsKigen::muggHgagaInt(const double sqrt_s) const
847 {
848  double muNWA, GammaRatio, fki;
849  double kt,kb,kc,ks,ku,kd,kta,km,ke;
850  double kw;
851  double kg,kgamma;
852 
853  muNWA = muggH(sqrt_s)*BrHgagaRatio();
854 
855  if (!FlagKiLoop) {
856 
857  kt = computeKt();
858  kb = computeKb();
859  kc = computeKc();
860  ks = computeKs();
861  ku = computeKu();
862  kd = computeKd();
863  kta = computeKtau();
864  km = computeKmu();
865  ke = computeKe();
866 
867  kw = computeKW();
868 
869  kg = 0.0;
870  kgamma = 0.0;
871 
872  GammaRatio = computeGammaTotalRatio();
873 
874 
875  fki = 0.000802422 *kb*kb + 0.000312884 *kb*kc + 0.0000182107 *kc*kc +
876  5.94769e-9 *kb*kd + 9.62554e-10 *kc*kd + 6.2785e-15 *kd*kd +
877  5.53251e-10 *kb*ke + 3.51863e-11 *kc*ke + 1.09243e-15 *kd*ke -
878  0.00905016 *kb*kg - 0.00190706 *kc*kg - 5.97591e-9 *kd*kg -
879  6.72288e-10 *ke*kg - 0.0271505 *kb*kgamma - 0.00143029 *kc*kgamma -
880  1.79277e-8 *kd*kgamma - 0.174392 *kg*kgamma + 8.97565e-6 *kb*km +
881  6.21013e-7 *kc*km + 2.37616e-11 *kd*km - 0.0000460022 *kg*km +
882  4.93348e-6 *kb*ks + 8.51176e-7 *kc*ks + 1.29558e-11 *kd*ks +
883  1.16267e-12 *ke*ks - 0.0000123381 *kg*ks - 0.0000370143 *kgamma*ks +
884  2.22544e-8 *km*ks + 6.08665e-9 *ks*ks - 0.0467672 *kb*kt -
885  0.00394193 *kc*kt - 3.08808e-8 *kd*kt - 6.94817e-10 *ke*kt -
886  0.240315 *kg*kt - 0.180236 *kgamma*kt - 0.0000475437 *km*kt -
887  0.0000637578 *ks*kt - 0.248368 *kt*kt + 0.00100168 *kb*kta +
888  0.0000759092 *kc*kta + 3.44671e-9 *kd*kta - 0.00975386 *kg*kta +
889  2.93009e-6 *ks*kta - 0.0100807 *kt*kta + 5.30126e-8 *kb*ku +
890  5.54256e-9 *kc*ku + 1.15815e-13 *kd*ku + 4.05206e-15 *ke*ku -
891  1.03323e-7 *kg*ku - 7.74926e-8 *kgamma*ku +
892  8.62762e-11 *km*ku + 1.17664e-10 *ks*ku - 2.13572e-7 *kt*ku +
893  1.2332e-8 *kta*ku + 3.40922e-13 *ku*ku + 0.169912 *kb*kw +
894  0.00895098 *kc*kw + 1.12194e-7 *kd*kw + 1.09137 *kg*kw +
895  0.000231641 *ks*kw + 1.12795 *kt*kw + 4.8496e-7 *ku*kw;
896 
897  return (muNWA - 0.022 *GammaRatio * fki)/0.978;
898  } else {
899  return muNWA;
900  }
901 }
902 
903 double HiggsKigen::muVBFHgaga(const double sqrt_s) const
904 {
905  return muVBF(sqrt_s)*BrHgagaRatio();
906 }
907 
908 double HiggsKigen::muZHgaga(const double sqrt_s) const
909 {
910  return muZH(sqrt_s)*BrHgagaRatio();
911 }
912 
913 double HiggsKigen::muWHgaga(const double sqrt_s) const
914 {
915  return muWH(sqrt_s)*BrHgagaRatio();
916 }
917 
918 double HiggsKigen::muVHgaga(const double sqrt_s) const
919 {
920  return muVH(sqrt_s)*BrHgagaRatio();
921 }
922 
923 double HiggsKigen::muttHgaga(const double sqrt_s) const
924 {
925  return muttH(sqrt_s)*BrHgagaRatio();
926 }
927 
928 double HiggsKigen::muggHZga(const double sqrt_s) const
929 {
930  return muggH(sqrt_s)*BrHZgaRatio();
931 }
932 
933 double HiggsKigen::muVBFHZga(const double sqrt_s) const
934 {
935  return muVBF(sqrt_s)*BrHZgaRatio();
936 }
937 
938 double HiggsKigen::muZHZga(const double sqrt_s) const
939 {
940  return muZH(sqrt_s)*BrHZgaRatio();
941 }
942 
943 double HiggsKigen::muWHZga(const double sqrt_s) const
944 {
945  return muWH(sqrt_s)*BrHZgaRatio();
946 }
947 
948 double HiggsKigen::muVHZga(const double sqrt_s) const
949 {
950  return muVH(sqrt_s)*BrHZgaRatio();
951 }
952 
953 double HiggsKigen::muttHZga(const double sqrt_s) const
954 {
955  return muttH(sqrt_s)*BrHZgaRatio();
956 }
957 
958 double HiggsKigen::muggHZZ(const double sqrt_s) const
959 {
960  return muggH(sqrt_s)*BrHZZRatio();
961 }
962 
963 double HiggsKigen::muVBFHZZ(const double sqrt_s) const
964 {
965  return muVBF(sqrt_s)*BrHZZRatio();
966 }
967 
968 double HiggsKigen::muZHZZ(const double sqrt_s) const
969 {
970  return muZH(sqrt_s)*BrHZZRatio();
971 }
972 
973 double HiggsKigen::muWHZZ(const double sqrt_s) const
974 {
975  return muWH(sqrt_s)*BrHZZRatio();
976 }
977 
978 double HiggsKigen::muVHZZ(const double sqrt_s) const
979 {
980  return muVH(sqrt_s)*BrHZZRatio();
981 }
982 
983 double HiggsKigen::muttHZZ(const double sqrt_s) const
984 {
985  return muttH(sqrt_s)*BrHZZRatio();
986 }
987 
988 double HiggsKigen::muggHZZ4l(const double sqrt_s) const
989 {
990  return muggH(sqrt_s)*BrHZZ4lRatio();
991 }
992 
993 double HiggsKigen::muVBFHZZ4l(const double sqrt_s) const
994 {
995  return muVBF(sqrt_s)*BrHZZ4lRatio();
996 }
997 
998 double HiggsKigen::muZHZZ4l(const double sqrt_s) const
999 {
1000  return muZH(sqrt_s)*BrHZZ4lRatio();
1001 }
1002 
1003 double HiggsKigen::muWHZZ4l(const double sqrt_s) const
1004 {
1005  return muWH(sqrt_s)*BrHZZ4lRatio();
1006 }
1007 
1008 double HiggsKigen::muVHZZ4l(const double sqrt_s) const
1009 {
1010  return muVH(sqrt_s)*BrHZZ4lRatio();
1011 }
1012 
1013 double HiggsKigen::muttHZZ4l(const double sqrt_s) const
1014 {
1015  return muttH(sqrt_s)*BrHZZ4lRatio();
1016 }
1017 
1018 double HiggsKigen::muggHWW(const double sqrt_s) const
1019 {
1020  return muggH(sqrt_s)*BrHWWRatio();
1021 }
1022 
1023 double HiggsKigen::muVBFHWW(const double sqrt_s) const
1024 {
1025  return muVBF(sqrt_s)*BrHWWRatio();
1026 }
1027 
1028 double HiggsKigen::muZHWW(const double sqrt_s) const
1029 {
1030  return muZH(sqrt_s)*BrHWWRatio();
1031 }
1032 
1033 double HiggsKigen::muWHWW(const double sqrt_s) const
1034 {
1035  return muWH(sqrt_s)*BrHWWRatio();
1036 }
1037 
1038 double HiggsKigen::muVHWW(const double sqrt_s) const
1039 {
1040  return muVH(sqrt_s)*BrHWWRatio();
1041 }
1042 
1043 double HiggsKigen::muttHWW(const double sqrt_s) const
1044 {
1045  return muttH(sqrt_s)*BrHWWRatio();
1046 }
1047 
1048 double HiggsKigen::muggHWW2l2v(const double sqrt_s) const
1049 {
1050  return muggH(sqrt_s)*BrHWW2l2vRatio();
1051 }
1052 
1053 double HiggsKigen::muVBFHWW2l2v(const double sqrt_s) const
1054 {
1055  return muVBF(sqrt_s)*BrHWW2l2vRatio();
1056 }
1057 
1058 double HiggsKigen::muZHWW2l2v(const double sqrt_s) const
1059 {
1060  return muZH(sqrt_s)*BrHWW2l2vRatio();
1061 }
1062 
1063 double HiggsKigen::muWHWW2l2v(const double sqrt_s) const
1064 {
1065  return muWH(sqrt_s)*BrHWW2l2vRatio();
1066 }
1067 
1068 double HiggsKigen::muVHWW2l2v(const double sqrt_s) const
1069 {
1070  return muVH(sqrt_s)*BrHWW2l2vRatio();
1071 }
1072 
1073 double HiggsKigen::muttHWW2l2v(const double sqrt_s) const
1074 {
1075  return muttH(sqrt_s)*BrHWW2l2vRatio();
1076 }
1077 
1078 double HiggsKigen::muggHmumu(const double sqrt_s) const
1079 {
1080  return muggH(sqrt_s)*BrHmumuRatio();
1081 }
1082 
1083 double HiggsKigen::muVBFHmumu(const double sqrt_s) const
1084 {
1085  return muVBF(sqrt_s)*BrHmumuRatio();
1086 }
1087 
1088 double HiggsKigen::muZHmumu(const double sqrt_s) const
1089 {
1090  return muZH(sqrt_s)*BrHmumuRatio();
1091 }
1092 
1093 double HiggsKigen::muWHmumu(const double sqrt_s) const
1094 {
1095  return muWH(sqrt_s)*BrHmumuRatio();
1096 }
1097 
1098 double HiggsKigen::muVHmumu(const double sqrt_s) const
1099 {
1100  return muVH(sqrt_s)*BrHmumuRatio();
1101 }
1102 
1103 double HiggsKigen::muttHmumu(const double sqrt_s) const
1104 {
1105  return muttH(sqrt_s)*BrHmumuRatio();
1106 }
1107 
1108 double HiggsKigen::muggHtautau(const double sqrt_s) const
1109 {
1110  return muggH(sqrt_s)*BrHtautauRatio();
1111 }
1112 
1113 double HiggsKigen::muVBFHtautau(const double sqrt_s) const
1114 {
1115  return muVBF(sqrt_s)*BrHtautauRatio();
1116 }
1117 
1118 double HiggsKigen::muZHtautau(const double sqrt_s) const
1119 {
1120  return muZH(sqrt_s)*BrHtautauRatio();
1121 }
1122 
1123 double HiggsKigen::muWHtautau(const double sqrt_s) const
1124 {
1125  return muWH(sqrt_s)*BrHtautauRatio();
1126 }
1127 
1128 double HiggsKigen::muVHtautau(const double sqrt_s) const
1129 {
1130  return muVH(sqrt_s)*BrHtautauRatio();
1131 }
1132 
1133 double HiggsKigen::muttHtautau(const double sqrt_s) const
1134 {
1135  return muttH(sqrt_s)*BrHtautauRatio();
1136 }
1137 
1138 double HiggsKigen::muggHbb(const double sqrt_s) const
1139 {
1140  return muggH(sqrt_s)*BrHbbRatio();
1141 }
1142 
1143 double HiggsKigen::muVBFHbb(const double sqrt_s) const
1144 {
1145  return muVBF(sqrt_s)*BrHbbRatio();
1146 }
1147 
1148 double HiggsKigen::muZHbb(const double sqrt_s) const
1149 {
1150  return muZH(sqrt_s)*BrHbbRatio();
1151 }
1152 
1153 double HiggsKigen::muWHbb(const double sqrt_s) const
1154 {
1155  return muWH(sqrt_s)*BrHbbRatio();
1156 }
1157 
1158 double HiggsKigen::muVHbb(const double sqrt_s) const
1159 {
1160  return muVH(sqrt_s)*BrHbbRatio();
1161 }
1162 
1163 double HiggsKigen::muttHbb(const double sqrt_s) const
1164 {
1165  return muttH(sqrt_s)*BrHbbRatio();
1166 }
1167 
1168 
1170 //-----------------------------------------------------------------------------------------
1171 //-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
1172 //-----------------------------------------------------------------------------------------
1174 
1175 double HiggsKigen::muTHUggHgaga(const double sqrt_s) const
1176 {
1177  return ( muggH(sqrt_s)*BrHgagaRatio() * (1.0 + eggFHgaga ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHgagaint + eHgagapar) );
1178 }
1179 
1180 double HiggsKigen::muTHUVBFHgaga(const double sqrt_s) const
1181 {
1182  return ( muVBF(sqrt_s)*BrHgagaRatio() * (1.0 + eVBFHgaga ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHgagaint + eHgagapar) );
1183 }
1184 
1185 double HiggsKigen::muTHUZHgaga(const double sqrt_s) const
1186 {
1187  return ( muZH(sqrt_s)*BrHgagaRatio() * (1.0 + eZHgaga ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHgagaint + eHgagapar) );
1188 }
1189 
1190 double HiggsKigen::muTHUWHgaga(const double sqrt_s) const
1191 {
1192  return ( muWH(sqrt_s)*BrHgagaRatio() * (1.0 + eWHgaga ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHgagaint + eHgagapar) );
1193 }
1194 
1195 double HiggsKigen::muTHUVHgaga(const double sqrt_s) const
1196 {
1197  // Theory uncertainty in VH production, from the WH and ZH ones
1198  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1199  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1200  double eVHtot,eVHgaga;
1201 
1202  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1203 
1204  eVHgaga = (eWHgaga * sigmaWH_SM + eZHgaga * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1205 
1206  return ( muVH(sqrt_s)*BrHgagaRatio() * (1.0 + eVHgaga ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHgagaint + eHgagapar) );
1207 }
1208 
1209 double HiggsKigen::muTHUttHgaga(const double sqrt_s) const
1210 {
1211  return ( muttH(sqrt_s)*BrHgagaRatio() * (1.0 + ettHgaga ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHgagaint + eHgagapar) );
1212 }
1213 
1214 double HiggsKigen::muTHUggHZga(const double sqrt_s) const
1215 {
1216  return ( muggH(sqrt_s)*BrHZgaRatio() * (1.0 + eggFHZga ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHZgaint + eHZgapar) );
1217 }
1218 
1219 double HiggsKigen::muTHUVBFHZga(const double sqrt_s) const
1220 {
1221  return ( muVBF(sqrt_s)*BrHZgaRatio() * (1.0 + eVBFHZga ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHZgaint + eHZgapar) );
1222 }
1223 
1224 double HiggsKigen::muTHUZHZga(const double sqrt_s) const
1225 {
1226  return ( muZH(sqrt_s)*BrHZgaRatio() * (1.0 + eZHZga ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHZgaint + eHZgapar) );
1227 }
1228 
1229 double HiggsKigen::muTHUWHZga(const double sqrt_s) const
1230 {
1231  return ( muWH(sqrt_s)*BrHZgaRatio() * (1.0 + eWHZga ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHZgaint + eHZgapar) );
1232 }
1233 
1234 double HiggsKigen::muTHUVHZga(const double sqrt_s) const
1235 {
1236  // Theory uncertainty in VH production, from the WH and ZH ones
1237  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1238  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1239  double eVHtot,eVHZga;
1240 
1241  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1242 
1243  eVHZga = (eWHZga * sigmaWH_SM + eZHZga * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1244 
1245  return ( muVH(sqrt_s)*BrHZgaRatio() * (1.0 + eVHZga ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHZgaint + eHZgapar) );
1246 }
1247 
1248 double HiggsKigen::muTHUttHZga(const double sqrt_s) const
1249 {
1250  return ( muttH(sqrt_s)*BrHZgaRatio() * (1.0 + ettHZga ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHZgaint + eHZgapar) );
1251 }
1252 
1253 double HiggsKigen::muTHUggHZZ(const double sqrt_s) const
1254 {
1255  return ( muggH(sqrt_s)*BrHZZRatio() * (1.0 + eggFHZZ ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHZZint + eHZZpar) );
1256 }
1257 
1258 double HiggsKigen::muTHUVBFHZZ(const double sqrt_s) const
1259 {
1260  return ( muVBF(sqrt_s)*BrHZZRatio() * (1.0 + eVBFHZZ ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHZZint + eHZZpar) );
1261 }
1262 
1263 double HiggsKigen::muTHUZHZZ(const double sqrt_s) const
1264 {
1265  return ( muZH(sqrt_s)*BrHZZRatio() * (1.0 + eZHZZ ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHZZint + eHZZpar) );
1266 }
1267 
1268 double HiggsKigen::muTHUWHZZ(const double sqrt_s) const
1269 {
1270  return ( muWH(sqrt_s)*BrHZZRatio() * (1.0 + eWHZZ ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHZZint + eHZZpar) );
1271 }
1272 
1273 double HiggsKigen::muTHUVHZZ(const double sqrt_s) const
1274 {
1275  // Theory uncertainty in VH production, from the WH and ZH ones
1276  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1277  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1278  double eVHtot,eVHZZ;
1279 
1280  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1281 
1282  eVHZZ = (eWHZZ * sigmaWH_SM + eZHZZ * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1283 
1284  return ( muVH(sqrt_s)*BrHZZRatio() * (1.0 + eVHZZ ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHZZint + eHZZpar) );
1285 }
1286 
1287 double HiggsKigen::muTHUttHZZ(const double sqrt_s) const
1288 {
1289  return ( muttH(sqrt_s)*BrHZZRatio() * (1.0 + ettHZZ ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHZZint + eHZZpar) );
1290 }
1291 
1292 double HiggsKigen::muTHUggHZZ4l(const double sqrt_s) const
1293 {
1294  return ( muggH(sqrt_s)*BrHZZ4lRatio() * (1.0 + eggFHZZ ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHZZint + eHZZpar) );
1295 }
1296 
1297 double HiggsKigen::muTHUVBFHZZ4l(const double sqrt_s) const
1298 {
1299  return ( muVBF(sqrt_s)*BrHZZ4lRatio() * (1.0 + eVBFHZZ ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHZZint + eHZZpar) );
1300 }
1301 
1302 double HiggsKigen::muTHUZHZZ4l(const double sqrt_s) const
1303 {
1304  return ( muZH(sqrt_s)*BrHZZ4lRatio() * (1.0 + eZHZZ ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHZZint + eHZZpar) );
1305 }
1306 
1307 double HiggsKigen::muTHUWHZZ4l(const double sqrt_s) const
1308 {
1309  return ( muWH(sqrt_s)*BrHZZ4lRatio() * (1.0 + eWHZZ ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHZZint + eHZZpar) );
1310 }
1311 
1312 double HiggsKigen::muTHUVHZZ4l(const double sqrt_s) const
1313 {
1314  // Theory uncertainty in VH production, from the WH and ZH ones
1315  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1316  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1317  double eVHtot,eVHZZ;
1318 
1319  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1320 
1321  eVHZZ = (eWHZZ * sigmaWH_SM + eZHZZ * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1322 
1323  return ( muVH(sqrt_s)*BrHZZ4lRatio() * (1.0 + eVHZZ ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHZZint + eHZZpar) );
1324 }
1325 
1326 double HiggsKigen::muTHUttHZZ4l(const double sqrt_s) const
1327 {
1328  return ( muttH(sqrt_s)*BrHZZ4lRatio() * (1.0 + ettHZZ ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHZZint + eHZZpar) );
1329 }
1330 
1331 double HiggsKigen::muTHUggHWW(const double sqrt_s) const
1332 {
1333  return ( muggH(sqrt_s)*BrHWWRatio() * (1.0 + eggFHWW ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHWWint + eHWWpar) );
1334 }
1335 
1336 double HiggsKigen::muTHUVBFHWW(const double sqrt_s) const
1337 {
1338  return ( muVBF(sqrt_s)*BrHWWRatio() * (1.0 + eVBFHWW ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHWWint + eHWWpar) );
1339 }
1340 
1341 double HiggsKigen::muTHUZHWW(const double sqrt_s) const
1342 {
1343  return ( muZH(sqrt_s)*BrHWWRatio() * (1.0 + eZHWW ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHWWint + eHWWpar) );
1344 }
1345 
1346 double HiggsKigen::muTHUWHWW(const double sqrt_s) const
1347 {
1348  return ( muWH(sqrt_s)*BrHWWRatio() * (1.0 + eWHWW ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHWWint + eHWWpar) );
1349 }
1350 
1351 double HiggsKigen::muTHUVHWW(const double sqrt_s) const
1352 {
1353  // Theory uncertainty in VH production, from the WH and ZH ones
1354  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1355  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1356  double eVHtot,eVHWW;
1357 
1358  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1359 
1360  eVHWW = (eWHWW * sigmaWH_SM + eZHWW * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1361 
1362  return ( muVH(sqrt_s)*BrHWWRatio() * (1.0 + eVHWW ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHWWint + eHWWpar) );
1363 }
1364 
1365 double HiggsKigen::muTHUttHWW(const double sqrt_s) const
1366 {
1367  return ( muttH(sqrt_s)*BrHWWRatio() * (1.0 + ettHWW ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHWWint + eHWWpar) );
1368 }
1369 
1370 double HiggsKigen::muTHUggHWW2l2v(const double sqrt_s) const
1371 {
1372  return ( muggH(sqrt_s)*BrHWW2l2vRatio() * (1.0 + eggFHWW ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHWWint + eHWWpar) );
1373 }
1374 
1375 double HiggsKigen::muTHUVBFHWW2l2v(const double sqrt_s) const
1376 {
1377  return ( muVBF(sqrt_s)*BrHWW2l2vRatio() * (1.0 + eVBFHWW ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHWWint + eHWWpar) );
1378 }
1379 
1380 double HiggsKigen::muTHUZHWW2l2v(const double sqrt_s) const
1381 {
1382  return ( muZH(sqrt_s)*BrHWW2l2vRatio() * (1.0 + eZHWW ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHWWint + eHWWpar) );
1383 }
1384 
1385 double HiggsKigen::muTHUWHWW2l2v(const double sqrt_s) const
1386 {
1387  return ( muWH(sqrt_s)*BrHWW2l2vRatio() * (1.0 + eWHWW ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHWWint + eHWWpar) );
1388 }
1389 
1390 double HiggsKigen::muTHUVHWW2l2v(const double sqrt_s) const
1391 {
1392  // Theory uncertainty in VH production, from the WH and ZH ones
1393  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1394  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1395  double eVHtot,eVHWW;
1396 
1397  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1398 
1399  eVHWW = (eWHWW * sigmaWH_SM + eZHWW * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1400 
1401  return ( muVH(sqrt_s)*BrHWW2l2vRatio() * (1.0 + eVHWW ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHWWint + eHWWpar) );
1402 }
1403 
1404 double HiggsKigen::muTHUttHWW2l2v(const double sqrt_s) const
1405 {
1406  return ( muttH(sqrt_s)*BrHWW2l2vRatio() * (1.0 + ettHWW ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHWWint + eHWWpar) );
1407 }
1408 
1409 double HiggsKigen::muTHUggHmumu(const double sqrt_s) const
1410 {
1411  return ( muggH(sqrt_s)*BrHmumuRatio() * (1.0 + eggFHmumu ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHmumuint + eHmumupar) );
1412 }
1413 
1414 double HiggsKigen::muTHUVBFHmumu(const double sqrt_s) const
1415 {
1416  return ( muVBF(sqrt_s)*BrHmumuRatio() * (1.0 + eVBFHmumu ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHmumuint + eHmumupar) );
1417 }
1418 
1419 double HiggsKigen::muTHUZHmumu(const double sqrt_s) const
1420 {
1421  return ( muZH(sqrt_s)*BrHmumuRatio() * (1.0 + eZHmumu ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHmumuint + eHmumupar) );
1422 }
1423 
1424 double HiggsKigen::muTHUWHmumu(const double sqrt_s) const
1425 {
1426  return ( muWH(sqrt_s)*BrHmumuRatio() * (1.0 + eWHmumu ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHmumuint + eHmumupar) );
1427 }
1428 
1429 double HiggsKigen::muTHUVHmumu(const double sqrt_s) const
1430 {
1431  // Theory uncertainty in VH production, from the WH and ZH ones
1432  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1433  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1434  double eVHtot,eVHmumu;
1435 
1436  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1437 
1438  eVHmumu = (eWHmumu * sigmaWH_SM + eZHmumu * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1439 
1440  return ( muVH(sqrt_s)*BrHmumuRatio() * (1.0 + eVHmumu ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHmumuint + eHmumupar) );
1441 }
1442 
1443 double HiggsKigen::muTHUttHmumu(const double sqrt_s) const
1444 {
1445  return ( muttH(sqrt_s)*BrHmumuRatio() * (1.0 + ettHmumu ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHmumuint + eHmumupar) );
1446 }
1447 
1448 double HiggsKigen::muTHUggHtautau(const double sqrt_s) const
1449 {
1450  return ( muggH(sqrt_s)*BrHtautauRatio() * (1.0 + eggFHtautau ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHtautauint + eHtautaupar) );
1451 }
1452 
1453 double HiggsKigen::muTHUVBFHtautau(const double sqrt_s) const
1454 {
1455  return ( muVBF(sqrt_s)*BrHtautauRatio() * (1.0 + eVBFHtautau ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHtautauint + eHtautaupar) );
1456 }
1457 
1458 double HiggsKigen::muTHUZHtautau(const double sqrt_s) const
1459 {
1460  return ( muZH(sqrt_s)*BrHtautauRatio() * (1.0 + eZHtautau ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHtautauint + eHtautaupar) );
1461 }
1462 
1463 double HiggsKigen::muTHUWHtautau(const double sqrt_s) const
1464 {
1465  return ( muWH(sqrt_s)*BrHtautauRatio() * (1.0 + eWHtautau ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHtautauint + eHtautaupar) );
1466 }
1467 
1468 double HiggsKigen::muTHUVHtautau(const double sqrt_s) const
1469 {
1470  // Theory uncertainty in VH production, from the WH and ZH ones
1471  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1472  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1473  double eVHtot,eVHtautau;
1474 
1475  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1476 
1477  eVHtautau = (eWHtautau * sigmaWH_SM + eZHtautau * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1478 
1479  return ( muVH(sqrt_s)*BrHtautauRatio() * (1.0 + eVHtautau ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHtautauint + eHtautaupar) );
1480 }
1481 
1482 double HiggsKigen::muTHUttHtautau(const double sqrt_s) const
1483 {
1484  return ( muttH(sqrt_s)*BrHtautauRatio() * (1.0 + ettHtautau ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHtautauint + eHtautaupar) );
1485 }
1486 
1487 double HiggsKigen::muTHUggHbb(const double sqrt_s) const
1488 {
1489  return ( muggH(sqrt_s)*BrHbbRatio() * (1.0 + eggFHbb ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHbbint + eHbbpar) );
1490 }
1491 
1492 double HiggsKigen::muTHUVBFHbb(const double sqrt_s) const
1493 {
1494  return ( muVBF(sqrt_s)*BrHbbRatio() * (1.0 + eVBFHbb ) * (1.0 + eHwidth)/(1.0 + eVBFint + eVBFpar)/(1.0 + eHbbint + eHbbpar) );
1495 }
1496 
1497 double HiggsKigen::muTHUZHbb(const double sqrt_s) const
1498 {
1499  return ( muZH(sqrt_s)*BrHbbRatio() * (1.0 + eZHbb ) * (1.0 + eHwidth)/(1.0 + eZHint + eZHpar)/(1.0 + eHbbint + eHbbpar) );
1500 }
1501 
1502 double HiggsKigen::muTHUWHbb(const double sqrt_s) const
1503 {
1504  return ( muWH(sqrt_s)*BrHbbRatio() * (1.0 + eWHbb ) * (1.0 + eHwidth)/(1.0 + eWHint + eWHpar)/(1.0 + eHbbint + eHbbpar) );
1505 }
1506 
1507 double HiggsKigen::muTHUVHbb(const double sqrt_s) const
1508 {
1509  // Theory uncertainty in VH production, from the WH and ZH ones
1510  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1511  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1512  double eVHtot,eVHbb;
1513 
1514  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1515 
1516  eVHbb = (eWHbb * sigmaWH_SM + eZHbb * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1517 
1518  return ( muVH(sqrt_s)*BrHbbRatio() * (1.0 + eVHbb ) * (1.0 + eHwidth)/(1.0 + eVHtot)/(1.0 + eHbbint + eHbbpar) );
1519 }
1520 
1521 double HiggsKigen::muTHUttHbb(const double sqrt_s) const
1522 {
1523  return ( muttH(sqrt_s)*BrHbbRatio() * (1.0 + ettHbb ) * (1.0 + eHwidth)/(1.0 + eeettHint + eeettHpar)/(1.0 + eHbbint + eHbbpar) );
1524 }
1525 
1526 double HiggsKigen::muTHUVBFBRinv(const double sqrt_s) const
1527 {
1528  return ( muVBF(sqrt_s)*Br_H_inv() * (1.0 + eVBFHinv ) /(1.0 + eVBFint + eVBFpar) );
1529 }
1530 
1531 double HiggsKigen::muTHUVBFHinv(const double sqrt_s) const
1532 {
1533  return ( muVBF(sqrt_s)*BrHtoinvRatio() * (1.0 + eVBFHinv ) /(1.0 + eVBFint + eVBFpar) );
1534 }
1535 
1536 double HiggsKigen::muTHUVHBRinv(const double sqrt_s) const
1537 {
1538  // Theory uncertainty in VH production, from the WH and ZH ones
1539  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1540  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1541  double eVHtot;
1542 
1543  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1544 
1545  return ( muVH(sqrt_s)*Br_H_inv() * (1.0 + eVHinv )/(1.0 + eVHtot) );
1546 }
1547 
1548 double HiggsKigen::muTHUVHinv(const double sqrt_s) const
1549 {
1550  // Theory uncertainty in VH production, from the WH and ZH ones
1551  double sigmaWH_SM = trueSM.computeSigmaWH(sqrt_s);
1552  double sigmaZH_SM = trueSM.computeSigmaZH(sqrt_s);
1553  double eVHtot;
1554 
1555  eVHtot = ((eWHint + eWHpar) * sigmaWH_SM + (eZHint + eZHpar) * sigmaZH_SM) / (sigmaWH_SM + sigmaZH_SM);
1556 
1557  return ( muVH(sqrt_s)*BrHtoinvRatio() * (1.0 + eVHinv )/(1.0 + eVHtot) );
1558 }
1559 
1560 double HiggsKigen::muTHUggHZZ4mu(const double sqrt_s) const
1561 {
1562  return ( muggH(sqrt_s)*BrHZZ4muRatio() * (1.0 + eggFHZZ ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHZZint + eHZZpar) );
1563 }
1564 
1565 double HiggsKigen::muTHUggHZgamumu(const double sqrt_s) const
1566 {
1567  return ( muggH(sqrt_s)*BrHZgamumuRatio() * (1.0 + eggFHZga ) * (1.0 + eHwidth)/(1.0 + eggFint + eggFpar)/(1.0 + eHZgaint + eHZgapar) );
1568 }
1569 
1571 //-----------------------------------------------------------------------------------------
1572 //-- Decays ---
1573 //-----------------------------------------------------------------------------------------
1575 
1576 double HiggsKigen::computeGammaTotalRatio() const
1577 {
1578  double GammaRatioSMmodes;
1579 
1580  GammaRatioSMmodes = computeGammaTotalSMRatio();
1581 
1582  return (GammaRatioSMmodes/(1.0 - BrHinv - BrHexo));
1583 
1584 }
1585 
1586 double HiggsKigen::computeGammaTotalnoErrorRatio() const
1587 {
1588  double GammaRatioSMmodes;
1589 
1590  GammaRatioSMmodes = computeGammaTotalSMnoErrorRatio();
1591 
1592  return (GammaRatioSMmodes/(1.0 - BrHinv - BrHexo));
1593 
1594 }
1595 
1596 double HiggsKigen::computeGammaTotalSMRatio() const
1597 {
1598  double GammaRatioSMmodes;
1599 
1600  GammaRatioSMmodes = ((computeKg() * computeKg() * (1.0 + eHggint + eHggpar) * trueSM.computeBrHtogg()
1601  + computeKW() * computeKW() * (1.0 + eHWWint + eHWWpar) * trueSM.computeBrHtoWW()
1602  + computeKZ() * computeKZ() * (1.0 + eHZZint + eHZZpar) * trueSM.computeBrHtoZZ()
1603  + computeKZga() * computeKZga() * (1.0 + eHZgaint + eHZgapar) * trueSM.computeBrHtoZga()
1604  + computeKgaga() * computeKgaga() * (1.0 + eHgagaint + eHgagapar) * trueSM.computeBrHtogaga()
1605  + computeKmu() * computeKmu() * (1.0 + eHmumuint + eHmumupar) * trueSM.computeBrHtomumu()
1606  + computeKtau() * computeKtau() * (1.0 + eHtautauint + eHtautaupar) * trueSM.computeBrHtotautau()
1607  + computeKc() * computeKc() * (1.0 + eHccint + eHccpar) * trueSM.computeBrHtocc()
1608  + computeKb() * computeKb() * (1.0 + eHbbint + eHbbpar) * trueSM.computeBrHtobb())
1609  / (trueSM.computeBrHtogg()
1610  + trueSM.computeBrHtoWW()
1611  + trueSM.computeBrHtoZZ()
1612  + trueSM.computeBrHtoZga()
1613  + trueSM.computeBrHtogaga()
1614  + trueSM.computeBrHtomumu()
1615  + trueSM.computeBrHtotautau()
1616  + trueSM.computeBrHtocc()
1617  + trueSM.computeBrHtobb()));
1618 
1619  return GammaRatioSMmodes;
1620 
1621 }
1622 
1623 double HiggsKigen::computeGammaTotalSMnoErrorRatio() const
1624 {
1625  double GammaRatioSMmodes;
1626 
1627  GammaRatioSMmodes = ((computeKg() * computeKg() * trueSM.computeBrHtogg()
1628  + computeKW() * computeKW() * trueSM.computeBrHtoWW()
1629  + computeKZ() * computeKZ() * trueSM.computeBrHtoZZ()
1630  + computeKZga() * computeKZga() * trueSM.computeBrHtoZga()
1631  + computeKgaga() * computeKgaga() * trueSM.computeBrHtogaga()
1632  + computeKmu() * computeKmu() * trueSM.computeBrHtomumu()
1633  + computeKtau() * computeKtau() * trueSM.computeBrHtotautau()
1634  + computeKc() * computeKc() * trueSM.computeBrHtocc()
1635  + computeKb() * computeKb() * trueSM.computeBrHtobb())
1636  / (trueSM.computeBrHtogg()
1637  + trueSM.computeBrHtoWW()
1638  + trueSM.computeBrHtoZZ()
1639  + trueSM.computeBrHtoZga()
1640  + trueSM.computeBrHtogaga()
1641  + trueSM.computeBrHtomumu()
1642  + trueSM.computeBrHtotautau()
1643  + trueSM.computeBrHtocc()
1644  + trueSM.computeBrHtobb()));
1645 
1646  return GammaRatioSMmodes;
1647 
1648 }
1649 
1650 double HiggsKigen::Br_H_exo() const
1651 {
1652  return BrHexo;
1653 };
1654 
1655 
1656 double HiggsKigen::Br_H_inv() const
1657 {
1658  return ( (trueSM.computeBrHtoZZinv())*BrHZZRatio() + BrHinv );
1659 }
1660 
1661 double HiggsKigen::Br_H_inv_NP() const
1662 {
1663  return BrHinv;
1664 }
1665 
1666 
1667 double HiggsKigen::BrHvisRatio() const
1668 {
1669  return (1.0 - Br_H_inv());
1670 }
1671 
1672 double HiggsKigen::BrHtoinvRatio() const
1673 {
1674  return (Br_H_inv()/(trueSM.computeBrHtoZZinv()));
1675 }
1676 
1678 
1679 double HiggsKigen::computeKg() const
1680 {
1681  return Kg;
1682 }
1683 
1684 double HiggsKigen::computeKW() const
1685 {
1686  return Kw;
1687 }
1688 
1689 double HiggsKigen::computeKZ() const
1690 {
1691  return Kz;
1692 }
1693 
1694 double HiggsKigen::computeKZga() const
1695 {
1696  return Kzga;
1697 }
1698 
1699 double HiggsKigen::computeKgaga() const
1700 {
1701  return Kga;
1702 }
1703 
1704 double HiggsKigen::computeKe() const
1705 {
1706  return Ke;
1707 }
1708 
1709 double HiggsKigen::computeKmu() const
1710 {
1711  return Kmu;
1712 }
1713 
1714 double HiggsKigen::computeKtau() const
1715 {
1716  return Ktau;
1717 }
1718 
1719 double HiggsKigen::computeKu() const
1720 {
1721  return Ku;
1722 }
1723 
1724 double HiggsKigen::computeKc() const
1725 {
1726  return Kc;
1727 }
1728 
1729 double HiggsKigen::computeKt() const
1730 {
1731  return Kt;
1732 }
1733 
1734 double HiggsKigen::computeKd() const
1735 {
1736  return Kd;
1737 }
1738 
1739 double HiggsKigen::computeKs() const
1740 {
1741  return Ks;
1742 }
1743 
1744 double HiggsKigen::computeKb() const
1745 {
1746  return Kb;
1747 }
1748 
1749 // USE THESE TO DEFINE KAPPAg,ETC
1750 
1751 double HiggsKigen::computeKgLoop() const
1752 {
1753  double Mt=trueSM.getQuarks(QCD::TOP).getMass();
1754  double Mb=trueSM.getQuarks(QCD::BOTTOM).getMass();
1755  double Mc=trueSM.getQuarks(QCD::CHARM).getMass();
1756  double TAUt=4.0*Mt*Mt/(mHl*mHl);
1757  double TAUb=4.0*Mb*Mb/(mHl*mHl);
1758  double TAUc=4.0*Mc*Mc/(mHl*mHl);
1759  double KgEff;
1760 
1761  KgEff = ( ( Kt * 0.5*TAUt*(1.0+(1.0-TAUt)*f_func(TAUt))
1762  +Kb * 0.5*TAUb*(1.0+(1.0-TAUb)*f_func(TAUb))
1763  +Kc * 0.5*TAUc*(1.0+(1.0-TAUc)*f_func(TAUc)) ) * (1.0+11.0*AlsMz/(4.0*M_PI))).abs2();
1764 
1765  KgEff = KgEff / ( ( 0.5*TAUt*(1.0+(1.0-TAUt)*f_func(TAUt))
1766  + 0.5*TAUb*(1.0+(1.0-TAUb)*f_func(TAUb))
1767  + 0.5*TAUc*(1.0+(1.0-TAUc)*f_func(TAUc)) ) * (1.0+11.0*AlsMz/(4.0*M_PI))).abs2();
1768 
1769  return (sqrt(KgEff));
1770 }
1771 
1772 double HiggsKigen::computeKZgaLoop() const
1773 {
1774  double Mt=trueSM.getQuarks(QCD::TOP).getMass();
1775  double Mb=trueSM.getQuarks(QCD::BOTTOM).getMass();
1776  double Mc=trueSM.getQuarks(QCD::CHARM).getMass();
1777  double Mtau=trueSM.getLeptons(StandardModel::TAU).getMass();
1778  double Mmu=trueSM.getLeptons(StandardModel::MU).getMass();
1779  double MW=trueSM.Mw_tree();
1780  double cW2=trueSM.c02();
1781  double sW2=1.0-cW2;
1782  double TAUt=4.0*Mt*Mt/(mHl*mHl);
1783  double TAUb=4.0*Mb*Mb/(mHl*mHl);
1784  double TAUc=4.0*Mc*Mc/(mHl*mHl);
1785  double TAUtau=4.0*Mtau*Mtau/(mHl*mHl);
1786  double TAUmu=4.0*Mmu*Mmu/(mHl*mHl);
1787  double TAUw=4.0*MW*MW/(mHl*mHl);
1788  double LAMt=4.0*Mt*Mt/(Mz*Mz);
1789  double LAMb=4.0*Mb*Mb/(Mz*Mz);
1790  double LAMc=4.0*Mc*Mc/(Mz*Mz);
1791  double LAMtau=4.0*Mtau*Mtau/(Mz*Mz);
1792  double LAMmu=4.0*Mmu*Mmu/(Mz*Mz);
1793  double LAMw=4.0*MW*MW/(Mz*Mz);
1794  double KZgaEff;
1795 
1796  KZgaEff = ((-Kt * 4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUt,LAMt)-Int2(TAUt,LAMt)) * (1.0-AlsMz/M_PI)
1797  +Kb * 2.0*(-0.5+2.0/3.0*sW2)*(Int1(TAUb,LAMb)-Int2(TAUb,LAMb))
1798  -Kc * 4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUc,LAMc)-Int2(TAUc,LAMc))
1799  +Ktau * 2.0*(-0.5+2.0*sW2)*(Int1(TAUtau,LAMtau)-Int2(TAUtau,LAMtau))
1800  +Kmu * 2.0*(-0.5+2.0*sW2)*(Int1(TAUmu,LAMmu)-Int2(TAUmu,LAMmu)) )/sqrt(sW2*cW2)
1801  -Kw * sqrt(cW2/sW2)*(4.0*(3.0-sW2/cW2)*Int2(TAUw,LAMw)
1802  +((1.0+2.0/TAUw)*sW2/cW2-(5.0+2.0/TAUw))*Int1(TAUw,LAMw))).abs2();
1803 
1804  KZgaEff = KZgaEff / ((-4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUt,LAMt)-Int2(TAUt,LAMt)) * (1.0-AlsMz/M_PI)
1805  + 2.0*(-0.5+2.0/3.0*sW2)*(Int1(TAUb,LAMb)-Int2(TAUb,LAMb))
1806  - 4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUc,LAMc)-Int2(TAUc,LAMc))
1807  + 2.0*(-0.5+2.0*sW2)*(Int1(TAUtau,LAMtau)-Int2(TAUtau,LAMtau))
1808  + 2.0*(-0.5+2.0*sW2)*(Int1(TAUmu,LAMmu)-Int2(TAUmu,LAMmu)) )/sqrt(sW2*cW2)
1809  - sqrt(cW2/sW2)*(4.0*(3.0-sW2/cW2)*Int2(TAUw,LAMw)
1810  +((1.0+2.0/TAUw)*sW2/cW2-(5.0+2.0/TAUw))*Int1(TAUw,LAMw))).abs2();
1811 
1812  return (sqrt(KZgaEff));
1813 }
1814 
1815 double HiggsKigen::computeKgagaLoop() const
1816 {
1817  double Mt=trueSM.getQuarks(QCD::TOP).getMass();
1818  double Mb=trueSM.getQuarks(QCD::BOTTOM).getMass();
1819  double Mc=trueSM.getQuarks(QCD::CHARM).getMass();
1820  double Mtau=trueSM.getLeptons(StandardModel::TAU).getMass();
1821  double Mmu=trueSM.getLeptons(StandardModel::MU).getMass();
1822  double MW=trueSM.Mw_tree();
1823  double TAUt=4.0*Mt*Mt/(mHl*mHl);
1824  double TAUb=4.0*Mb*Mb/(mHl*mHl);
1825  double TAUc=4.0*Mc*Mc/(mHl*mHl);
1826  double TAUtau=4.0*Mtau*Mtau/(mHl*mHl);
1827  double TAUmu=4.0*Mmu*Mmu/(mHl*mHl);
1828  double TAUw=4.0*MW*MW/(mHl*mHl);
1829  double KgagaEff;
1830 
1831  KgagaEff = ( Kt * (8./3.)*TAUt*(1.+(1.-TAUt)*f_func(TAUt)) * (1.0-AlsMz/M_PI)
1832  +Kb * (2./3.)*TAUb*(1.+(1.-TAUb)*f_func(TAUb))
1833  +Kc * (8./3.)*TAUc*(1.+(1.-TAUc)*f_func(TAUc))
1834  +Ktau * 2.0*TAUtau*(1.+(1.-TAUtau)*f_func(TAUtau))
1835  +Kmu * 2.0*TAUmu*(1.+(1.-TAUmu)*f_func(TAUmu))
1836  -Kw * (2.0+3.0*TAUw+3.0*TAUw*(2.0-TAUw)*f_func(TAUw)) ).abs2();
1837 
1838  KgagaEff = KgagaEff / ( (8./3.)*TAUt*(1.+(1.-TAUt)*f_func(TAUt)) * (1.0-AlsMz/M_PI)
1839  + (2./3.)*TAUb*(1.+(1.-TAUb)*f_func(TAUb))
1840  + (8./3.)*TAUc*(1.+(1.-TAUc)*f_func(TAUc))
1841  + 2.0*TAUtau*(1.+(1.-TAUtau)*f_func(TAUtau))
1842  + 2.0*TAUmu*(1.+(1.-TAUmu)*f_func(TAUmu))
1843  - (2.0+3.0*TAUw+3.0*TAUw*(2.0-TAUw)*f_func(TAUw)) ).abs2();
1844 
1845  return (sqrt(KgagaEff));
1846 }
1847 
1849 
1850 double HiggsKigen::deltaG_hgg() const
1851 {
1852  // Not needed/implemented yet
1853  return 0.0;
1854 }
1855 
1856 double HiggsKigen::deltaG_hggRatio() const{
1857  return (computeKg() - 1.0);
1858 }
1859 
1860 double HiggsKigen::deltaG1_hWW() const{
1861  return 0.0;
1862 }
1863 
1864 double HiggsKigen::deltaG2_hWW() const{
1865  return 0.0;
1866 }
1867 
1868 double HiggsKigen::deltaG3_hWW() const{
1869 
1870  double gSM = 2.0 * (trueSM.Mw_tree())* (trueSM.Mw_tree()) / (trueSM.v());
1871 
1872  return ( gSM * (computeKW() - 1.0 ) );
1873 }
1874 
1875 double HiggsKigen::deltaG1_hZZ() const{
1876  return 0.0;
1877 }
1878 
1879 double HiggsKigen::deltaG2_hZZ() const{
1880  return 0.0;
1881 }
1882 
1883 double HiggsKigen::deltaG3_hZZ() const{
1884 
1885  double gSM = (trueSM.getMz()) * (trueSM.getMz()) / (trueSM.v());
1886 
1887  return ( gSM * (computeKZ() - 1.0 ) );
1888 }
1889 
1890 double HiggsKigen::deltaG1_hZA() const{
1891  // Not needed/implemented yet
1892  return 0.0;
1893 }
1894 
1895 double HiggsKigen::deltaG1_hZARatio() const{
1896  return (computeKZga() - 1.0);
1897 }
1898 
1899 double HiggsKigen::deltaG2_hZA() const{
1900  return 0.0;
1901 }
1902 
1903 double HiggsKigen::deltaG_hAA() const{
1904  // Not needed/implemented yet
1905  return 0.0;
1906 }
1907 
1908 double HiggsKigen::deltaG_hAARatio() const{
1909  return (computeKgaga() - 1.0);
1910 }
1911 
1912 gslpp::complex HiggsKigen::deltaG_hff(const Particle p) const{
1913 
1914  double gSM = -(p.getMass()) / (trueSM.v());
1915 
1916  if ( p.is("ELECTRON") ) {
1917  return ( gSM * (computeKe() - 1.0 ) );
1918  } else if ( p.is("MU") ) {
1919  return ( gSM * (computeKmu() - 1.0 ) );
1920  } else if ( p.is("TAU") ) {
1921  return ( gSM * (computeKtau() - 1.0 ) );
1922  } else if ( p.is("UP") ) {
1923  return ( gSM * (computeKu() - 1.0 ) );
1924  } else if ( p.is("CHARM") ) {
1925  return ( gSM * (computeKc() - 1.0 ) );
1926  } else if ( p.is("TOP") ) {
1927  return ( gSM * (computeKt() - 1.0 ) );
1928  } else if ( p.is("DOWN") ) {
1929  return ( gSM * (computeKd() - 1.0 ) );
1930  } else if ( p.is("STRANGE") ) {
1931  return ( gSM * (computeKs() - 1.0 ) );
1932  } else if ( p.is("BOTTOM") ) {
1933  return ( gSM * (computeKb() - 1.0 ) );
1934  } else {
1935  return 0.0;
1936  }
1937 }
1938 
1940 
1941 double HiggsKigen::kappamueff() const
1942 {
1943  return computeKmu();
1944 }
1945 
1946 double HiggsKigen::kappataueff() const
1947 {
1948  return computeKtau();
1949 }
1950 
1951 double HiggsKigen::kappaceff() const
1952 {
1953  return computeKc();
1954 }
1955 
1956 double HiggsKigen::kappabeff() const
1957 {
1958  return computeKb();
1959 }
1960 
1961 double HiggsKigen::kappaGeff() const
1962 {
1963  return computeKg();
1964 }
1965 
1966 double HiggsKigen::kappaZeff() const
1967 {
1968  return computeKZ();
1969 }
1970 
1971 double HiggsKigen::kappaWeff() const
1972 {
1973  return computeKW();
1974 }
1975 
1976 double HiggsKigen::kappaAeff() const
1977 {
1978  return computeKgaga();
1979 }
1980 
1981 double HiggsKigen::kappaZAeff() const
1982 {
1983  return computeKZga();
1984 }
1985 
1987 
1988 gslpp::complex HiggsKigen::f_func(const double x) const{
1989  if(x<1) {
1990  gslpp::complex z = -gslpp::complex::i()*M_PI;
1991  return -pow(log((1+sqrt(1-x))/(1-sqrt(1-x)))+z,2)/4.0;
1992  }
1993  else {
1994  return pow(asin(sqrt(1.0/x)),2);
1995  }
1996 }
1997 
1998 gslpp::complex HiggsKigen::g_func(const double x) const{
1999  if(x<1) {
2000  gslpp::complex z = -gslpp::complex::i()*M_PI;
2001  gslpp::complex gs1 = sqrt(1.0-x)*(log((1.0+sqrt(1.0-x))/(1.0-sqrt(1.0-x)))+z)/2.0;
2002  return gs1;
2003  }
2004  else {
2005  gslpp::complex gg1 = sqrt(x-1.0)*asin(sqrt(1.0/x));
2006  return gg1;
2007  }
2008 }
2009 
2010 gslpp::complex HiggsKigen::Int1(const double tau, const double lambda) const{
2011  return tau*lambda/(tau-lambda)/2.0+tau*tau*lambda*lambda/((tau-lambda)
2012  *(tau-lambda))/2.0*(f_func(tau)-f_func(lambda))+tau*tau*lambda/((tau-lambda)
2013  *(tau-lambda))*(g_func(tau)-g_func(lambda));
2014 }
2015 
2016 gslpp::complex HiggsKigen::Int2(const double tau, const double lambda) const{
2017  return -tau*lambda/(tau-lambda)/2.0*(f_func(tau)-f_func(lambda));
2018 }
2019 
2020 
QCD::TAU
Definition: QCD.h:316
HiggsKigen::eHWWpar
double eHWWpar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2232
HiggsKigen::eWHbb
double eWHbb
Definition: HiggsKigen.h:2250
HiggsKigen::eWHZZ
double eWHZZ
Definition: HiggsKigen.h:2250
sigmattH
Definition: NPSMEFT6dtopquark.h:606
HiggsKigen::BrHZZ4muRatio
virtual double BrHZZ4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:772
HiggsKigen::muVBFHZZ4l
virtual double muVBFHZZ4l(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:993
HiggsKigen::FlagUniversalK
bool FlagUniversalK
A boolean flag that is true if all K take the same universal value.
Definition: HiggsKigen.h:2268
HiggsKigen::muTHUttHZZ4l
virtual double muTHUttHZZ4l(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1326
HiggsKigen::muWHZga
virtual double muWHZga(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:943
HiggsKigen::eggFpar
double eggFpar
Parametric relative theoretical error in ggF production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2210
HiggsKigen::eVBFHZZ
double eVBFHZZ
Definition: HiggsKigen.h:2249
HiggsKigen::muTHUttHZZ
virtual double muTHUttHZZ(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1287
StandardModel::cW2
virtual double cW2(const double Mw_i) const
The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as .
Definition: StandardModel.cpp:989
HiggsKigen::eHZZint
double eHZZint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2233
HiggsKigen::BrHtoinvRatio
virtual double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:1672
HiggsKigen::muTHUZHmumu
virtual double muTHUZHmumu(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1419
StandardModel::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.
Definition: StandardModel.cpp:231
StandardModel::v
virtual double v() const
The Higgs vacuum expectation value.
Definition: StandardModel.cpp:917
HiggsKigen::muTHUVHbb
virtual double muTHUVHbb(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1507
HiggsKigen::eWHmumu
double eWHmumu
Total relative theoretical error in .
Definition: HiggsKigen.h:2250
HiggsKigen::kappaceff
virtual double kappaceff() const
The effective coupling .
Definition: HiggsKigen.cpp:1951
HiggsKigen::muVBFHWW
virtual double muVBFHWW(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1023
HiggsKigen::mueeWBFPol
virtual double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:546
HiggsKigen::muTHUVHZZ
virtual double muTHUVHZZ(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1273
QCD::BOTTOM
Definition: QCD.h:329
HiggsKigen::muWHWW
virtual double muWHWW(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1033
HiggsKigen::Br_H_exo
virtual double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles (invisible or not).
Definition: HiggsKigen.cpp:1650
HiggsKigen::BrHccRatio
virtual double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:820
Particle::is
bool is(std::string name_i) const
Definition: Particle.cpp:23
Particle
A class for particles.
Definition: Particle.h:26
HiggsKigen::muttHtautau
virtual double muttHtautau(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1133
StandardModel::computeSigmaWH
double computeSigmaWH(const double sqrt_s) const
The WH production cross section in the Standard Model.
Definition: StandardModel.h:2088
HiggsKigen::muTHUVBFHWW2l2v
virtual double muTHUVBFHWW2l2v(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1375
HiggsKigen::muTHUVHinv
virtual double muTHUVHinv(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into invisible states in the...
Definition: HiggsKigen.cpp:1548
HiggsKigen::muTHUggHZZ
virtual double muTHUggHZZ(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1253
HiggsKigen::muTHUggHbb
virtual double muTHUggHbb(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1487
HiggsKigen::FlagKiLoop
bool FlagKiLoop
A boolean flag that is true if one allows independent kappa's for the loop induced processes (g,...
Definition: HiggsKigen.h:2265
HiggsKigen::muWH
virtual double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: HiggsKigen.cpp:599
HiggsKigen::eepWBFint
double eepWBFint
Intrinsic relative theoretical error in via WBF. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2225
HiggsKigen::muTHUVBFHZZ4l
virtual double muTHUVBFHZZ4l(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1297
HiggsKigen::muTHUggHtautau
virtual double muTHUggHtautau(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1448
HiggsKigen::Kg
double Kg
The factor rescaling the effective Higgs couplings to gluons with respect to the SM.
Definition: HiggsKigen.h:2193
HiggsKigen::muTHUggHWW
virtual double muTHUggHWW(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1331
HiggsKigen::eHmumuint
double eHmumuint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2239
StandardModel::computeBrHtotautau
double computeBrHtotautau() const
The Br in the Standard Model.
Definition: StandardModel.h:2264
HiggsKigen::computeKc
virtual double computeKc() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1724
HiggsKigen::muttHZZ4l
virtual double muttHZZ4l(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1013
HiggsKigen::eeeWBFpar
double eeeWBFpar
Parametric relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2220
HiggsKigen::GammaHTotR
double GammaHTotR
Total Higgs width ratio with respect to SM.
Definition: HiggsKigen.h:2258
HiggsKigen::mueeZqqHPol
virtual double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:648
HiggsKigen::muTHUZHZZ
virtual double muTHUZHZZ(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1263
HiggsKigen::computeKgagaLoop
virtual double computeKgagaLoop() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1815
HiggsKigen::Kz
double Kz
The factor rescaling the SM-like Higgs couplings to the Z vector bosons with respect to the SM.
Definition: HiggsKigen.h:2192
HiggsKigen::Ku
double Ku
The factor rescaling the Higgs couplings to the up quark with respect to the SM.
Definition: HiggsKigen.h:2196
HiggsKigen::computeGammaTotalSMRatio
virtual double computeGammaTotalSMRatio() const
The ratio of the in the current model and in the Standard Model, including only SM decays.
Definition: HiggsKigen.cpp:1596
HiggsKigen::deltaG_hggRatio
virtual double deltaG_hggRatio() const
The full new physics contribution to the coupling of the effective interaction , including new local ...
Definition: HiggsKigen.cpp:1856
HiggsKigen::eVHinv
double eVHinv
Total relative theoretical error in .
Definition: HiggsKigen.h:2253
HiggsKigen::eHtautaupar
double eHtautaupar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2242
HiggsKigen::deltaG_hff
virtual gslpp::complex deltaG_hff(const Particle p) const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1912
HiggsKigen::muVHZga
virtual double muVHZga(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:948
HiggsKigen::muTHUVHtautau
virtual double muTHUVHtautau(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1468
HiggsKigen::muTHUVHgaga
virtual double muTHUVHgaga(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:1195
HiggsKigen::deltaG3_hWW
virtual double deltaG3_hWW() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1868
HiggsKigen::muTHUVBFBRinv
virtual double muTHUVBFBRinv(const double sqrt_s) const
The ratio between the VBF production cross-section in the current model and in the Standard Model,...
Definition: HiggsKigen.cpp:1526
HiggsKigen::muZHbb
virtual double muZHbb(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1148
HiggsKigen::muttHZZ
virtual double muttHZZ(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:983
HiggsKigen::computeKmu
virtual double computeKmu() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1709
HiggsKigen::eHZZpar
double eHZZpar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2234
HiggsKigen::mueeZBFPol
virtual double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:578
HiggsKigen::eHccpar
double eHccpar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2244
HiggsKigen::FlagCustodial
bool FlagCustodial
A boolean flag that is true if KZ=KW.
Definition: HiggsKigen.h:2266
HiggsKigen::muTHUVBFHbb
virtual double muTHUVBFHbb(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1492
HiggsKigen::GammaHTotSMR
double GammaHTotSMR
Total Higgs width ratio with respect to SM (only SM channels)
Definition: HiggsKigen.h:2259
HiggsKigen::eZHZga
double eZHZga
Definition: HiggsKigen.h:2251
HiggsKigen::BrHtautauRatio
virtual double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:813
StandardModel::computeSigmaWF
double computeSigmaWF(const double sqrt_s) const
The W fusion contribution to higgs-production cross section in the Standard Model.
Definition: StandardModel.h:2017
HiggsKigen::muggHWW
virtual double muggHWW(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1018
HiggsKigen::muWHtautau
virtual double muWHtautau(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1123
HiggsKigen::muTHUZHbb
virtual double muTHUZHbb(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1497
HiggsKigen::eHWWint
double eHWWint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2231
HiggsKigen::eVBFpar
double eVBFpar
Parametric relative theoretical error in VBF production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2214
HiggsKigen::muZHZZ4l
virtual double muZHZZ4l(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:998
HiggsKigen::BrHZZ4eRatio
virtual double BrHZZ4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:762
HiggsKigen::Int2
gslpp::complex Int2(const double tau, const double lambda) const
Definition: HiggsKigen.cpp:2016
Model::addMissingModelParameter
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:232
StandardModel::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for StandardModel have been provided in model initi...
Definition: StandardModel.cpp:313
HiggsKigen::BrHinv
double BrHinv
The branching ratio of invisible Higgs decays.
Definition: HiggsKigen.h:2206
HiggsKigen::muggHZZ4l
virtual double muggHZZ4l(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:988
QCD::CHARM
Definition: QCD.h:326
HiggsKigen::computeGammaTotalRatio
virtual double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:1576
HiggsKigen::Ktau
double Ktau
The factor rescaling the Higgs couplings to taus with respect to the SM.
Definition: HiggsKigen.h:2204
HiggsKigen::mueeZqqH
virtual double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:627
HiggsKigen::eVBFHbb
double eVBFHbb
Definition: HiggsKigen.h:2249
StandardModel::computeBrHtobb
double computeBrHtobb() const
The Br in the Standard Model.
Definition: StandardModel.h:2299
HiggsKigen::mueettHPol
virtual double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:724
HiggsKigen::Kmu
double Kmu
The factor rescaling the Higgs couplings to muons with respect to the SM.
Definition: HiggsKigen.h:2203
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
HiggsKigen::BrHZgaeeRatio
virtual double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:789
HiggsKigen::muTHUWHZga
virtual double muTHUWHZga(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1229
StandardModel::mHl
double mHl
The Higgs mass in GeV.
Definition: StandardModel.h:2514
HiggsKigen::computeKg
virtual double computeKg() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1679
HiggsKigen::deltaG1_hZZ
virtual double deltaG1_hZZ() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1875
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
HiggsKigen::muTHUVBFHWW
virtual double muTHUVBFHWW(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1336
HiggsKigen::deltaG_hAARatio
virtual double deltaG_hAARatio() const
The full new physics contribution to the coupling of the effective interaction , including new local ...
Definition: HiggsKigen.cpp:1908
HiggsKigen::muggHmumu
virtual double muggHmumu(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1078
HiggsKigen::eWHWW
double eWHWW
Definition: HiggsKigen.h:2250
HiggsKigen::kappaGeff
virtual double kappaGeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1961
HiggsKigen::mueeZllH
virtual double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:620
HiggsKigen::deltaG1_hZARatio
virtual double deltaG1_hZARatio() const
The full new physics contribution to the coupling of the effective interaction , including new local ...
Definition: HiggsKigen.cpp:1895
HiggsKigen::muTHUWHWW2l2v
virtual double muTHUWHWW2l2v(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1385
HiggsKigen::muttHWW
virtual double muttHWW(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1043
HiggsKigen::BrHZgallRatio
virtual double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:784
HiggsKigen::muTHUttHWW
virtual double muTHUttHWW(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1365
HiggsKigen::eepZBFint
double eepZBFint
Intrinsic relative theoretical error in via ZBF. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2227
HiggsKigen::kappataueff
virtual double kappataueff() const
The effective coupling .
Definition: HiggsKigen.cpp:1946
HiggsKigen::eeettHpar
double eeettHpar
Parametric relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2224
HiggsKigen::muggHgaga
virtual double muggHgaga(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: HiggsKigen.cpp:841
HiggsKigen::muggHZga
virtual double muggHZga(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:928
HiggsKigen::deltaG3_hZZ
virtual double deltaG3_hZZ() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1883
HiggsKigen::deltaG_hgg
virtual double deltaG_hgg() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1850
HiggsKigen::eZHbb
double eZHbb
Definition: HiggsKigen.h:2251
HiggsKigen::ettHgaga
double ettHgaga
Definition: HiggsKigen.h:2252
HiggsKigen::muTHUVBFHZga
virtual double muTHUVBFHZga(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1219
HiggsKigen::eggFHbb
double eggFHbb
Definition: HiggsKigen.h:2248
HiggsKigen::BrHZgaRatio
virtual double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:777
HiggsKigen::ettHpar
double ettHpar
Parametric relative theoretical error in ttH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2212
HiggsKigen::eVBFint
double eVBFint
Intrinsic relative theoretical error in VBF production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2213
StandardModel::cW2
virtual double cW2() const
Definition: StandardModel.cpp:994
HiggsKigen::BrHZZRatio
virtual double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:750
HiggsKigen::eHmumupar
double eHmumupar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2240
HiggsKigen::NHKvKfgenvars
static const int NHKvKfgenvars
The number of the model parameters in HiggsKigen: 17 modelpars + 38 + 37 th. err. pars.
Definition: HiggsKigen.h:201
HiggsKigen::eHccint
double eHccint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2243
HiggsKigen::muZHZga
virtual double muZHZga(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:938
HiggsKigen::muggHtautau
virtual double muggHtautau(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1108
HiggsKigen::muTHUVBFHmumu
virtual double muTHUVBFHmumu(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1414
HiggsKigen::eHbbpar
double eHbbpar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2246
StandardModel::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of StandardModel.
Definition: StandardModel.cpp:378
Model::ModelParamMap
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:262
HiggsKigen::Kzga
double Kzga
The factor rescaling the effective Higgs couplings to the Z and a photon with respect to the SM.
Definition: HiggsKigen.h:2195
HiggsKigen::muVHgaga
virtual double muVHgaga(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:918
HiggsKigen::FlagUniversalKf
bool FlagUniversalKf
A boolean flag that is true if all Kf take the same universal value.
Definition: HiggsKigen.h:2267
HiggsKigen::computeKZga
virtual double computeKZga() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1694
HiggsKigen::KH
double KH
The factor rescaling the total Higgs width with respect to the SM.
Definition: HiggsKigen.h:2205
HiggsKigen::BrHmumuRatio
virtual double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:806
HiggsKigen::mueeZllHPol
virtual double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:641
HiggsKigen::muTHUVHZZ4l
virtual double muTHUVHZZ4l(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1312
StandardModel::computeSigmaZF
double computeSigmaZF(const double sqrt_s) const
The Z fusion contribution to higgs-production cross section in the Standard Model.
Definition: StandardModel.h:2045
HiggsKigen::BrHWWRatio
virtual double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:738
NPbase::trueSM
StandardModel trueSM
Definition: NPbase.h:2787
HiggsKigen::muZHmumu
virtual double muZHmumu(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1088
StandardModel::computeBrHtoZZ
double computeBrHtoZZ() const
The Br in the Standard Model.
Definition: StandardModel.h:2208
HiggsKigen::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of HiggsKigen.
Definition: HiggsKigen.cpp:439
HiggsKigen::muTHUttHZga
virtual double muTHUttHZga(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1248
StandardModel::c02
double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel.cpp:939
HiggsKigen::muttHWW2l2v
virtual double muttHWW2l2v(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1073
HiggsKigen::deltaG_hAA
virtual double deltaG_hAA() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1903
HiggsKigen::deltaG2_hZZ
virtual double deltaG2_hZZ() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1879
HiggsKigen::muTHUVHWW2l2v
virtual double muTHUVHWW2l2v(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1390
HiggsKigen::muTHUVHWW
virtual double muTHUVHWW(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1351
HiggsKigen::muttHmumu
virtual double muttHmumu(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1103
HiggsKigen::computeKtau
virtual double computeKtau() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1714
HiggsKigen::Ks
double Ks
The factor rescaling the Higgs couplings to the strange quark with respect to the SM.
Definition: HiggsKigen.h:2200
HiggsKigen::eHggpar
double eHggpar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2230
Particle::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
HiggsKigen::muepZBF
virtual double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:592
HiggsKigen::computeKZgaLoop
virtual double computeKZgaLoop() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1772
HiggsKigen::eZHWW
double eZHWW
Definition: HiggsKigen.h:2251
HiggsKigen::BrHZgamumuRatio
virtual double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:794
StandardModel::AlsMz
double AlsMz
The strong coupling constant at the Z-boson mass, .
Definition: StandardModel.h:2509
NPbase
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
HiggsKigen::eggFint
double eggFint
Intrinsic relative theoretical error in ggF production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2209
StandardModel::sW2
double sW2() const
Definition: StandardModel.cpp:1005
HiggsKigen::muTHUWHmumu
virtual double muTHUWHmumu(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1424
HiggsKigen::Kw
double Kw
The factor rescaling the SM-like Higgs couplings to the W vector bosons with respect to the SM.
Definition: HiggsKigen.h:2191
HiggsKigen::muTHUggHZZ4l
virtual double muTHUggHZZ4l(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1292
HiggsKigen::computeKW
virtual double computeKW() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1684
HiggsKigen::FlagUseKH
bool FlagUseKH
A boolean flag that is true if the Higgs width is rescaled by KH. (See above for the description of f...
Definition: HiggsKigen.h:2269
HiggsKigen::eZHtautau
double eZHtautau
Definition: HiggsKigen.h:2251
HiggsKigen::computeKs
virtual double computeKs() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1739
HiggsKigen::Kc
double Kc
The factor rescaling the Higgs couplings to the charm quark with respect to the SM.
Definition: HiggsKigen.h:2197
HiggsKigen::muggHZZ
virtual double muggHZZ(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:958
HiggsKigen::muVHmumu
virtual double muVHmumu(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1098
HiggsKigen::Kga
double Kga
The factor rescaling the effective Higgs couplings to photons with respect to the SM.
Definition: HiggsKigen.h:2194
HiggsKigen::muZHZZ
virtual double muZHZZ(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:968
HiggsKigen::eZHmumu
double eZHmumu
Total relative theoretical error in .
Definition: HiggsKigen.h:2251
HiggsKigen::muttHZga
virtual double muttHZga(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:953
QCD::TOP
Definition: QCD.h:328
HiggsKigen::muVHWW2l2v
virtual double muVHWW2l2v(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1068
HiggsKigen::Kd
double Kd
The factor rescaling the Higgs couplings to the down quark with respect to the SM.
Definition: HiggsKigen.h:2199
HiggsKigen::BrHbbRatio
virtual double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:827
HiggsKigen::muttH
virtual double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: HiggsKigen.cpp:680
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
HiggsKigen::eVBFHinv
double eVBFHinv
Definition: HiggsKigen.h:2253
HiggsKigen::muTHUttHbb
virtual double muTHUttHbb(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1521
HiggsKigen::mueeHvv
virtual double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:553
Model::raiseMissingModelParameterCount
void raiseMissingModelParameterCount()
Definition: Model.h:242
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
HiggsKigen::eggFHWW
double eggFHWW
Definition: HiggsKigen.h:2248
HiggsKigen::muTHUZHZZ4l
virtual double muTHUZHZZ4l(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1302
gslpp::complex::i
static const complex & i()
Definition: gslpp_complex.cpp:154
HiggsKigen::kappaAeff
virtual double kappaAeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1976
HiggsKigen::Br_H_inv_NP
virtual double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: HiggsKigen.cpp:1661
HiggsKigen::muTHUttHmumu
virtual double muTHUttHmumu(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1443
HiggsKigen::muttHbb
virtual double muttHbb(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1163
StandardModel::computeBrHtoZga
double computeBrHtoZga() const
The Br in the Standard Model.
Definition: StandardModel.h:2230
StandardModel::lambda
double lambda
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:2524
HiggsKigen::muTHUWHWW
virtual double muTHUWHWW(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1346
StandardModel::computeBrHtogaga
double computeBrHtogaga() const
The Br in the Standard Model.
Definition: StandardModel.h:2242
HiggsKigen::eVBFHZga
double eVBFHZga
Definition: HiggsKigen.h:2249
HiggsKigen::muTHUWHgaga
virtual double muTHUWHgaga(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:1190
StandardModel::computeSigmaggH
double computeSigmaggH(const double sqrt_s) const
The ggH cross section in the Standard Model.
Definition: StandardModel.h:1883
HiggsKigen::mueettH
virtual double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:710
HiggsKigen.h
HiggsKigen::muTHUggHWW2l2v
virtual double muTHUggHWW2l2v(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1370
HiggsKigen::ettHbb
double ettHbb
Definition: HiggsKigen.h:2252
HiggsKigen::eHtautauint
double eHtautauint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2241
HiggsKigen::obliqueU
virtual double obliqueU() const
The oblique parameter .
Definition: HiggsKigen.cpp:504
HiggsKigen::kappamueff
virtual double kappamueff() const
The effective coupling .
Definition: HiggsKigen.cpp:1941
HiggsKigen::muTHUZHWW
virtual double muTHUZHWW(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1341
HiggsKigen::f_func
gslpp::complex f_func(const double x) const
Definition: HiggsKigen.cpp:1988
HiggsKigen::muggHpttH
virtual double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: HiggsKigen.cpp:699
HiggsKigen::muVHtautau
virtual double muVHtautau(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1128
HiggsKigen::ettHZga
double ettHZga
Definition: HiggsKigen.h:2252
HiggsKigen::kappaZeff
virtual double kappaZeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1966
HiggsKigen::BrHZZ4lRatio
virtual double BrHZZ4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:757
StandardModel::computeSigmattH
double computeSigmattH(const double sqrt_s) const
The ttH production cross section in the Standard Model.
Definition: StandardModel.h:2157
QCD::getQuarks
Particle getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:534
HiggsKigen::eVBFHmumu
double eVBFHmumu
Total relative theoretical error in .
Definition: HiggsKigen.h:2249
HiggsKigen::eZHZZ
double eZHZZ
Definition: HiggsKigen.h:2251
HiggsKigen::muTHUZHWW2l2v
virtual double muTHUZHWW2l2v(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1380
HiggsKigen::mueeZH
virtual double mueeZH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:613
HiggsKigen::muggHbb
virtual double muggHbb(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1138
HiggsKigen::eWHpar
double eWHpar
Parametric relative theoretical error in WH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2216
HiggsKigen::computeGammaTotalSMnoErrorRatio
virtual double computeGammaTotalSMnoErrorRatio() const
The ratio of the in the current model and in the Standard Model, including only SM decays and neglec...
Definition: HiggsKigen.cpp:1623
HiggsKigen::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for HiggsKigen have been provided in model initiali...
Definition: HiggsKigen.cpp:427
HiggsKigen::muVH
virtual double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: HiggsKigen.cpp:655
HiggsKigen::muVHbb
virtual double muVHbb(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1158
HiggsKigen::muTHUttHgaga
virtual double muTHUttHgaga(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into 2 photons in the curre...
Definition: HiggsKigen.cpp:1209
HiggsKigen::eZHint
double eZHint
Intrinsic relative theoretical error in ZH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2217
HiggsKigen::muTHUWHbb
virtual double muTHUWHbb(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1502
HiggsKigen::eWHZga
double eWHZga
Definition: HiggsKigen.h:2250
HiggsKigen::muTHUZHgaga
virtual double muTHUZHgaga(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:1185
HiggsKigen::eVBFHWW
double eVBFHWW
Definition: HiggsKigen.h:2249
HiggsKigen::muepWBF
virtual double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:585
HiggsKigen::ettHWW
double ettHWW
Definition: HiggsKigen.h:2252
HiggsKigen::muZHWW2l2v
virtual double muZHWW2l2v(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1058
HiggsKigen::eggFHgaga
double eggFHgaga
Definition: HiggsKigen.h:2248
HiggsKigen::muVBFHgaga
virtual double muVBFHgaga(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into 2 photons in the...
Definition: HiggsKigen.cpp:903
HiggsKigen::muVBFHbb
virtual double muVBFHbb(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1143
HiggsKigen::muTHUggHgaga
virtual double muTHUggHgaga(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: HiggsKigen.cpp:1175
HiggsKigen::muTHUVBFHtautau
virtual double muTHUVBFHtautau(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1453
HiggsKigen::muTHUVHBRinv
virtual double muTHUVHBRinv(const double sqrt_s) const
The ratio between the VH production cross-section in the current model and in the Standard Model,...
Definition: HiggsKigen.cpp:1536
HiggsKigen::muTHUWHZZ
virtual double muTHUWHZZ(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1268
HiggsKigen::eggFHtautau
double eggFHtautau
Definition: HiggsKigen.h:2248
HiggsKigen::g_func
gslpp::complex g_func(const double x) const
Definition: HiggsKigen.cpp:1998
HiggsKigen::eZHpar
double eZHpar
Parametric relative theoretical error in ZH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2218
HiggsKigen::muTHUggHZga
virtual double muTHUggHZga(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1214
HiggsKigen::muVBFgamma
virtual double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: HiggsKigen.cpp:531
HiggsKigen::muTHUggHZZ4mu
virtual double muTHUggHZZ4mu(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1560
HiggsKigen::ettHmumu
double ettHmumu
Total relative theoretical error in .
Definition: HiggsKigen.h:2252
HiggsKigen::muTHUVBFHgaga
virtual double muTHUVBFHgaga(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into 2 photons in the...
Definition: HiggsKigen.cpp:1180
HiggsKigen::eeettHint
double eeettHint
Intrinsic relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2223
HiggsKigen::eWHgaga
double eWHgaga
Definition: HiggsKigen.h:2250
HiggsKigen::computeKe
virtual double computeKe() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1704
HiggsKigen::muTHUVHmumu
virtual double muTHUVHmumu(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1429
HiggsKigen::muWHWW2l2v
virtual double muWHWW2l2v(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1063
HiggsKigen::eeeZHint
double eeeZHint
Intrinsic relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2221
HiggsKigen::computeGammaTotalnoErrorRatio
virtual double computeGammaTotalnoErrorRatio() const
The ratio of the in the current model and in the Standard Model and neglecting theory errors.
Definition: HiggsKigen.cpp:1586
HiggsKigen::eepWBFpar
double eepWBFpar
Parametric relative theoretical error in via WBF. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2226
StandardModel::computeSigmaZH
double computeSigmaZH(const double sqrt_s) const
The ZH production cross section in the Standard Model.
Definition: StandardModel.h:2121
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:718
HiggsKigen::muVHWW
virtual double muVHWW(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1038
HiggsKigen::Ke
double Ke
The factor rescaling the Higgs couplings to electrons with respect to the SM.
Definition: HiggsKigen.h:2202
StandardModel::computeBrHtocc
double computeBrHtocc() const
The Br in the Standard Model.
Definition: StandardModel.h:2276
HiggsKigen::muVBFHWW2l2v
virtual double muVBFHWW2l2v(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1053
HiggsKigen::muggH
virtual double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: HiggsKigen.cpp:511
HiggsKigen::muTHUVBFHinv
virtual double muTHUVBFHinv(const double sqrt_s) const
The ratio between the VBF production cross-section with subsequent decay into invisible states in th...
Definition: HiggsKigen.cpp:1531
HiggsKigen::computeKt
virtual double computeKt() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1729
HiggsKigen::muTHUggHZgamumu
virtual double muTHUggHZgamumu(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1565
HiggsKigen::computeKgaga
virtual double computeKgaga() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1699
HiggsKigen::kappaZAeff
virtual double kappaZAeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1981
HiggsKigen::Br_H_inv
virtual double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: HiggsKigen.cpp:1656
HiggsKigen::BrHgagaRatio
virtual double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:799
StandardModel::Mw_tree
virtual double Mw_tree() const
The tree-level mass of the boson, .
Definition: StandardModel.cpp:925
HiggsKigen::BrHggRatio
virtual double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:731
HiggsKigen::muggHgagaInt
virtual double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: HiggsKigen.cpp:846
StandardModel::computeBrHtomumu
double computeBrHtomumu() const
The Br in the Standard Model.
Definition: StandardModel.h:2253
HiggsKigen::muZH
virtual double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: HiggsKigen.cpp:606
HiggsKigen::eHwidth
double eHwidth
Total relative theoretical error in the Higgs width.
Definition: HiggsKigen.h:2255
HiggsKigen::muTHUZHtautau
virtual double muTHUZHtautau(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1458
HiggsKigen::eVBFHgaga
double eVBFHgaga
Definition: HiggsKigen.h:2249
StandardModel::computeBrHtoWW
double computeBrHtoWW() const
The Br in the Standard Model.
Definition: StandardModel.h:2196
HiggsKigen::HiggsKigen
HiggsKigen()
The default constructor.
Definition: HiggsKigen.cpp:27
HiggsKigen::computeKb
virtual double computeKb() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1744
HiggsKigen::BrHWW2l2vRatio
virtual double BrHWW2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:745
HiggsKigen::muZHtautau
virtual double muZHtautau(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1118
HiggsKigen::muttHZbbboost
virtual double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:834
HiggsKigen::Int1
gslpp::complex Int1(const double tau, const double lambda) const
Definition: HiggsKigen.cpp:2010
HiggsKigen::muVHZZ4l
virtual double muVHZZ4l(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1008
HiggsKigen::muTHUVHZga
virtual double muTHUVHZga(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1234
HiggsKigen::eHZgapar
double eHZgapar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2236
HiggsKigen::muTHUZHZga
virtual double muTHUZHZga(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1224
HiggsKigen::muZHWW
virtual double muZHWW(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1028
HiggsKigen::ettHZZ
double ettHZZ
Definition: HiggsKigen.h:2252
HiggsKigen::muTHUWHtautau
virtual double muTHUWHtautau(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1463
HiggsKigen::muVBF
virtual double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: HiggsKigen.cpp:518
HiggsKigen::eeeZHpar
double eeeZHpar
Parametric relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2222
HiggsKigen::GammaHTotnoER
double GammaHTotnoER
Total Higgs width ratio with respect to SM, neglecting theory errors.
Definition: HiggsKigen.h:2261
HiggsKigen::eHgagapar
double eHgagapar
Parametric relative theoretical error in .
Definition: HiggsKigen.h:2238
HiggsKigen::muVBFHZZ
virtual double muVBFHZZ(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:963
HiggsKigen::Kb
double Kb
The factor rescaling the Higgs couplings to the bottom quark with respect to the SM.
Definition: HiggsKigen.h:2201
HiggsKigen::muWHZZ
virtual double muWHZZ(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:973
HiggsKigen::mutHq
virtual double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: HiggsKigen.cpp:687
HiggsKigen::eggFHZZ
double eggFHZZ
Definition: HiggsKigen.h:2248
HiggsKigen::mueeZHPol
virtual double mueeZHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:634
HiggsKigen::eHgagaint
double eHgagaint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2237
NPbase::PostUpdate
virtual bool PostUpdate()
The postupdate method for NPbase.
Definition: NPbase.cpp:23
HiggsKigen::eZHgaga
double eZHgaga
Definition: HiggsKigen.h:2251
StandardModel::computeBrHtogg
double computeBrHtogg() const
The Br in the Standard Model.
Definition: StandardModel.h:2185
Model::name
std::string name
The name of the model.
Definition: Model.h:267
StandardModel::Mz
double Mz
The mass of the boson in GeV.
Definition: StandardModel.h:2510
HiggsKigen::obliqueS
virtual double obliqueS() const
The oblique parameter .
Definition: HiggsKigen.cpp:465
HiggsKigen::kappaWeff
virtual double kappaWeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1971
HiggsKigen::ettHtautau
double ettHtautau
Definition: HiggsKigen.h:2252
HiggsKigen::muTHUWHZZ4l
virtual double muTHUWHZZ4l(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1307
HiggsKigen::muWHZZ4l
virtual double muWHZZ4l(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1003
HiggsKigen::deltaG1_hWW
virtual double deltaG1_hWW() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1860
StandardModel::computeBrHtoZZinv
double computeBrHtoZZinv() const
The Br in the Standard Model.
Definition: StandardModel.h:2219
HiggsKigen::computeKgLoop
virtual double computeKgLoop() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1751
StandardModel::computeSigmaZWF
double computeSigmaZWF(const double sqrt_s) const
The Z W interference fusion contribution to higgs-production cross section in the Standard Model.
Definition: StandardModel.h:2072
HiggsKigen::eWHtautau
double eWHtautau
Definition: HiggsKigen.h:2250
HiggsKigen::BrHZZ2e2muRatio
virtual double BrHZZ2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:767
HiggsKigen::muZHgaga
virtual double muZHgaga(const double sqrt_s) const
The ratio between the ZH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:908
HiggsKigen::muWHgaga
virtual double muWHgaga(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into 2 photons in the curren...
Definition: HiggsKigen.cpp:913
HiggsKigen::muVHZZ
virtual double muVHZZ(const double sqrt_s) const
The ratio between the VH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:978
HiggsKigen::muVBFHZga
virtual double muVBFHZga(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:933
HiggsKigen::muTHUVBFHZZ
virtual double muTHUVBFHZZ(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1258
HiggsKigen::muWHmumu
virtual double muWHmumu(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1093
HiggsKigen::deltaG2_hZA
virtual double deltaG2_hZA() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1899
HiggsKigen::computeKZ
virtual double computeKZ() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1689
HiggsKigen::GammaHTotSMnoER
double GammaHTotSMnoER
Total Higgs width ratio with respect to SM, neglecting theory errors (only SM channels)
Definition: HiggsKigen.h:2262
HiggsKigen::kappabeff
virtual double kappabeff() const
The effective coupling .
Definition: HiggsKigen.cpp:1956
HiggsKigen::eVBFHtautau
double eVBFHtautau
Definition: HiggsKigen.h:2249
HiggsKigen::eggFHZga
double eggFHZga
Definition: HiggsKigen.h:2248
HiggsKigen::obliqueT
virtual double obliqueT() const
The oblique parameter .
Definition: HiggsKigen.cpp:484
HiggsKigen::eHbbint
double eHbbint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2245
HiggsKigen::computeKd
virtual double computeKd() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1734
HiggsKigen::muggHWW2l2v
virtual double muggHWW2l2v(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1048
HiggsKigen::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of HiggsKigen.
Definition: HiggsKigen.cpp:235
HiggsKigen::BrHexo
double BrHexo
The branching ratio of exotic (not invisible) Higgs decays.
Definition: HiggsKigen.h:2207
HiggsKigen::eggFHmumu
double eggFHmumu
Total relative theoretical error in .
Definition: HiggsKigen.h:2248
HiggsKigen::muVBFHmumu
virtual double muVBFHmumu(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1083
HiggsKigen::eepZBFpar
double eepZBFpar
Parametric relative theoretical error in via ZBF. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2228
HiggsKigen::mueeHvvPol
virtual double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: HiggsKigen.cpp:562
HiggsKigen::PostUpdate
virtual bool PostUpdate()
The post-update method for HiggsKigen.
Definition: HiggsKigen.cpp:130
HiggsKigen::HKvKfgenvars
static const std::string HKvKfgenvars[NHKvKfgenvars]
A string array containing the labels of the model parameters in HiggsKigen.
Definition: HiggsKigen.h:206
HiggsKigen::muttHgaga
virtual double muttHgaga(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into 2 photons in the curre...
Definition: HiggsKigen.cpp:923
HiggsKigen::mummH
virtual double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:717
HiggsKigen::deltaG1_hZA
virtual double deltaG1_hZA() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1890
HiggsKigen::muTHUttHtautau
virtual double muTHUttHtautau(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1482
HiggsKigen::BrHvisRatio
virtual double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:1667
HiggsKigen::ettHint
double ettHint
Intrinsic relative theoretical error in ttH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2211
HiggsKigen::eHggint
double eHggint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2229
HiggsKigen::eWHint
double eWHint
Intrinsic relative theoretical error in WH production. (Assumed to be constant in energy....
Definition: HiggsKigen.h:2215
HiggsKigen::mueeWBF
virtual double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:539
QCD::MU
Definition: QCD.h:314
HiggsKigen::Kt
double Kt
The factor rescaling the Higgs couplings to the top quark with respect to the SM.
Definition: HiggsKigen.h:2198
HiggsKigen::muTHUggHmumu
virtual double muTHUggHmumu(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into ...
Definition: HiggsKigen.cpp:1409
HiggsKigen::muVBFpVH
virtual double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: HiggsKigen.cpp:664
HiggsKigen::muTHUttHWW2l2v
virtual double muTHUttHWW2l2v(const double sqrt_s) const
The ratio between the ttH production cross-section with subsequent decay into in the current model ...
Definition: HiggsKigen.cpp:1404
HiggsKigen::computeKu
virtual double computeKu() const
A method to compute the ratio of the coupling in the current model and in the SM.
Definition: HiggsKigen.cpp:1719
HiggsKigen::mueeZBF
virtual double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: HiggsKigen.cpp:571
StandardModel::getLeptons
Particle getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
Definition: StandardModel.h:709
HiggsKigen::muVBFHtautau
virtual double muVBFHtautau(const double sqrt_s) const
The ratio between the VBF Higgs production cross-section with subsequent decay into in the current ...
Definition: HiggsKigen.cpp:1113
HiggsKigen::eeeWBFint
double eeeWBFint
Intrinsic relative theoretical error in . (Assumed to be constant in energy.)
Definition: HiggsKigen.h:2219
HiggsKigen::deltaG2_hWW
virtual double deltaG2_hWW() const
The new physics contribution to the coupling of the effective interaction .
Definition: HiggsKigen.cpp:1864
HiggsKigen::eHZgaint
double eHZgaint
Intrinsic relative theoretical error in .
Definition: HiggsKigen.h:2235
HiggsKigen::muWHbb
virtual double muWHbb(const double sqrt_s) const
The ratio between the WH production cross-section with subsequent decay into in the current model a...
Definition: HiggsKigen.cpp:1153