a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
GMcache.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2017 HEPfit Collaboration
3  * All rights reserved.
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "gslpp.h"
9 #include "GMcache.h"
10 #include <fstream>
11 #include <sstream>
12 #include <string>
13 
14 GMcache::GMcache(const StandardModel& SM_i)
15  : br_aa(19961, 2, 0.),
16  br_tt(19961, 2, 0.),
17  br_bb(19961, 2, 0.),
18  br_tautau(19961, 2, 0.),
19  br_cc(19961, 2, 0.),
20  br_mumu(19961, 2, 0.),
21  br_ZZ(19961, 2, 0.),
22  br_WW(19961, 2, 0.),
23  GammaHtot_SM(19961, 2, 0.),
24  log_cs_ggH_8(199, 2, 0.),
25  log_cs_VBF_8(199, 2, 0.),
26  log_cs_WH_8(199, 2, 0.),
27  log_cs_ZH_8(199, 2, 0.),
28  log_cs_ggH_13(199, 2, 0.),
29  log_cs_VBF_13(199, 2, 0.),
30  log_cs_WH_13(199, 2, 0.),
31  log_cs_ZH_13(199, 2, 0.),
32  log_cs_ttH_8(199, 2, 0.),
33  log_cs_ttH_13(199, 2, 0.),
34  log_cs_bbH_8(199, 2, 0.),
35  log_cs_bbH_13(199, 2, 0.),
36  log_cs_ggA_8(199, 2, 0.),
37  log_cs_ttA_8(199, 2, 0.),
38  log_cs_bbA_8(199, 2, 0.),
39  log_cs_ggA_13(199, 2, 0.),
40  log_cs_ttA_13(199, 2, 0.),
41  log_cs_bbA_13(199, 2, 0.),
42  log_cs_ggHp_8(744, 3, 0.),
43  log_cs_ggHp_13(1104, 3, 0.),
44  log_cs_ppH5ppH5mm_8(18, 2, 0.),
45  log_cs_ppH5ppH5mm_13(38, 2, 0.),
46  log_cs_VBFH5_8(41, 2, 0.),
47  log_cs_VBFH5_13(91, 2, 0.),
48  log_cs_VBFH5m_8(41, 2, 0.),
49  log_cs_VBFH5m_13(91, 2, 0.),
50  log_cs_VBFH5mm_8(41, 2, 0.),
51  log_cs_VBFH5mm_13(91, 2, 0.),
52  log_cs_VBFH5p_8(41, 2, 0.),
53  log_cs_VBFH5p_13(91, 2, 0.),
54  log_cs_VBFH5pp_8(41, 2, 0.),
55  log_cs_VBFH5pp_13(91, 2, 0.),
56  log_cs_VHH5_8(18, 2, 0.),
57  log_cs_VHH5_13(38, 2, 0.),
58  log_cs_VHH5mm_8(18, 2, 0.),
59  log_cs_VHH5mm_13(38, 2, 0.),
60  log_cs_VHH5pp_8(18, 2, 0.),
61  log_cs_VHH5pp_13(38, 2, 0.),
62  /* Neutral searches */
63  ATLAS13_tt_phi_tt(61,2,0.),
64  ATLAS13_bb_phi_tt(61,2,0.),
65  CMS8_bb_phi_bb(81, 2, 0.),
66  CMS8_gg_phi_bb(88, 2, 0.),
67  CMS13_pp_phi_bb(66,2,0.),
68  CMS13_bb_phi_bb(101, 2, 0.),
69  ATLAS8_gg_phi_tautau(92, 2, 0.),
70  CMS8_gg_phi_tautau(92,2,0.),
71  ATLAS8_bb_phi_tautau(92, 2, 0.),
72  CMS8_bb_phi_tautau(92,2,0.),
73  ATLAS13_gg_phi_tautau(206,2,0.),
74  CMS13_gg_phi_tautau(312,2,0.),
75  ATLAS13_bb_phi_tautau(206,2,0.),
76  CMS13_bb_phi_tautau(312,2,0.),
77  ATLAS8_gg_phi_gaga(108, 2, 0.),
78  ATLAS13_pp_phi_gaga(251,2,0.),
79  CMS13_gg_phi_gaga(351,2,0.),
80  ATLAS8_pp_phi_Zga_llga(141, 2, 0.),
81  CMS8_pp_phi_Zga_llga(101,2,0.),
82  ATLAS13_gg_phi_Zga_llga(216,2,0.),
83  ATLAS13_gg_phi_Zga_qqga(581,2,0.),
84  CMS13_gg_phi_Zga(366,2,0.),
85  ATLAS8_gg_phi_ZZ(173,2,0.),
86  ATLAS8_VV_phi_ZZ(173,2,0.),
87  ATLAS13_gg_phi_ZZ_llllnunu(101,2,0.),
88  ATLAS13_VV_phi_ZZ_llllnunu(101,2,0.),
89  ATLAS13_gg_phi_ZZ_qqllnunu(271,2,0.),
90  ATLAS13_VV_phi_ZZ_qqllnunu(271,2,0.),
91  CMS13_pp_phi_ZZ_llqqnunull(288,2,0.),
92  CMS13_VV_phi_ZZ_llqqnunull(288,2,0.),
93  CMS13_pp_phi_ZZ_qqnunu(301,2,0.),
94  ATLAS8_gg_phi_WW(13,2,0.),
95  ATLAS8_VV_phi_WW(13,2,0.),
96  ATLAS13_gg_phi_WW_enumunu(381,2,0.),
97  ATLAS13_VV_phi_WW_enumunu(281,2,0.),
98  ATLAS13_gg_phi_WW_lnuqq(271,2,0.),
99  ATLAS13_VV_phi_WW_lnuqq(271,2,0.),
100  CMS13_ggVV_phi_WW_lnulnu(81,2,0.),
101  CMS13_pp_phi_WW_lnuqq(341,2,0.),
102  CMS8_mu_pp_phi_VV(172, 2, 0.),
103  ATLAS13_pp_phi_VV_qqqq(181,2,0.),
104  ATLAS8_gg_phi_hh(75,2,0.),
105  CMS8_pp_phi_hh_bbbb(167, 2, 0.),
106  CMS8_pp_phi_hh_gagabb(85, 2, 0.),
107  CMS8_gg_phi_hh_bbtautau(10,2,0.),
108  CMS8_pp_phi_hh_bbtautau(71,2,0.),
109  ATLAS13_pp_phi_hh_bbbb(275,2,0.),
110  CMS13_pp_phi_hh_bbbb_1(95,2,0.),
111  CMS13_pp_phi_hh_bbbb_2(181,2,0.),
112  CMS13_gg_phi_hh_bbbb(226,2,0.),
113  ATLAS13_pp_phi_hh_gagabb(75,2,0.),
114  CMS13_pp_phi_hh_gagabb(66,2,0.),
115  ATLAS13_pp_phi_hh_bbtautau(75,2,0.),
116  CMS13_pp_phi_hh_bbtautau_1(66,2,0.),
117  CMS13_pp_phi_hh_bbtautau_2(311,2,0.),
118  CMS13_pp_phi_hh_bblnulnu(65,2,0.),
119  ATLAS13_gg_phi_hh_gagaWW(25,2,0.),
120  ATLAS8_gg_A_hZ_bbZ(79, 2, 0.),
121  CMS8_gg_A_hZ_bbll(16, 2, 0.),
122  ATLAS8_gg_A_hZ_tautauZ(79, 2, 0.),
123  CMS8_gg_A_hZ_tautaull(14,2,0.),
124  ATLAS13_gg_A_Zh_Zbb(181,2,0.),
125  ATLAS13_bb_A_Zh_Zbb(181,2,0.),
126  CMS13_gg_A_Zh_Zbb_1(79,2,0.),
127  CMS13_bb_A_Zh_Zbb_1(79,2,0.),
128  CMS13_gg_A_Zh_Zbb_2(121,2,0.),
129  CMS13_bb_A_Zh_Zbb_2(121,2,0.),
130  CMS8_pp_A_phiZ_bbll(28718, 3, 0.),
131  CMS8_pp_phi_AZ_bbll(29050, 3, 0.),
132  ATLAS13_gg_A_phiZ_bbll(3364, 3, 0.),
133  ATLAS13_bb_A_phiZ_bbll(3364, 3, 0.),
134  /* Charged searches */
135  ATLAS8_pp_Hpm_taunu(83,2,0.),
136  CMS8_pp_Hp_taunu(43,2,0.),
137  ATLAS13_pp_Hpm_taunu(192,2,0.),
138  CMS13_pp_Hpm_taunu(283,2,0.),
139  ATLAS8_pp_Hpm_tb(41,2,0.),
140  CMS8_pp_Hp_tb(43,2,0.),
141  ATLAS13_pp_Hpm_tb(181,2,0.),
142  ATLAS8_WZ_H5pm_WZ_qqll(81,2,0.),
143  ATLAS13_WZ_H5pm_WZ_lnull(71,2,0.),
144  CMS13_WZ_H5pm_WZ_lnull_1(181,2,0.),
145  CMS13_WZ_H5pm_WZ_lnull_2(171,2,0.),
146  ATLAS8_pp_H5ppmmH5mmpp_eeee(50,2,0.),
147  ATLAS8_pp_H5ppmmH5mmpp_emuemu(57,2,0.),
148  ATLAS8_pp_H5ppmmH5mmpp_mumumumu(57,2,0.),
149  ATLAS13_pp_H5ppmmH5mmpp_llll(96,2,0.),
150  ATLAS13_pp_H5ppmmH5mmpp_WWWW(51,2,0.),
151  CMS8_VV_H5ppmm_WW_jjll(65,2,0.),
152  CMS13_VV_H5ppmm_WW_jjll(81,2,0.),
153  ATLAS13_WZ_H5pm_WZ_lnull_e(15,2,0.),
154  unitarityeigenvalues(17, 0.),
155  myGM(static_cast<const GeorgiMachacek*> (&SM_i))
156 {
157  read();
158 // myRunnerGM=new RunnerGM(SM_i);
159 }
160 
161 GMcache::~GMcache()
162 {
163 // delete myRunnerGM;
164 }
165 //
167 //
168 int GMcache::CacheCheck(const gslpp::complex cache[][CacheSize],
169  const int NumPar, const double params[]) const {
170  bool bCache;
171  for(int i=0; i<CacheSize; i++) {
172  bCache = true;
173  for(int j=0; j<NumPar; j++)
174  bCache &= (params[j] == cache[j][i].real());
175  if (bCache) return i;
176  }
177  return -1;
178 }
179 
180 int GMcache::CacheCheckReal(const double cache[][CacheSize],
181  const int NumPar, const double params[]) const {
182  bool bCache;
183  for(int i=0; i<CacheSize; i++) {
184  bCache = true;
185  for(int j=0; j<NumPar; j++)
186  bCache &= (params[j] == cache[j][i]);
187  if (bCache) return i;
188  }
189  return -1;
190 }
191 
192 void GMcache::CacheShift(gslpp::complex cache[][CacheSize], const int NumPar,
193  const double params[], const gslpp::complex newResult) const {
194  // shift old parameters and result
195  for(int i=CacheSize-1; i>0; i--)
196  for(int j=0; j<NumPar+1; j++)
197  cache[j][i] = cache[j][i-1];
198 
199  // store new parameters and result
200  for(int j=0; j<NumPar; j++) {
201  cache[j][0] = gslpp::complex(params[j], 0.0, false);
202  cache[NumPar][0] = newResult;
203  }
204 }
205 
206 void GMcache::CacheShiftReal(double cache[][CacheSize], const int NumPar,
207  const double params[], const double newResult) const {
208  // shift old parameters and result
209  for(int i=CacheSize-1; i>0; i--)
210  for(int j=0; j<NumPar+1; j++)
211  cache[j][i] = cache[j][i-1];
212 
213  // store new parameters and result
214  for(int j=0; j<NumPar; j++) {
215  cache[j][0] = params[j];
216  cache[NumPar][0] = newResult;
217  }
218 }
219 
220 void GMcache::read(){
221 
222  std::stringstream br1,br1a,br2,br3,br4,br5,br6,br7;
223  std::stringstream dw1;
224  std::stringstream cs1,cs2,cs3,cs4,cs5,cs6,cs7,cs8,cs9;
225  std::stringstream cs11,cs12,cs13,cs14,cs15,cs16,cs17,cs18,cs19;
226  std::stringstream cs20,cs21,cs22,cs23,cs24,cs25,cs26,cs27,cs28,cs29;
227  std::stringstream cs30,cs31,cs32,cs33,cs34,cs35,cs36,cs37,cs38,cs39;
228  std::stringstream ex1,ex2,ex3,ex4,ex5,ex6,ex7,ex8,ex9,ex10,ex11,ex12,ex13,ex14,ex15;
229  std::stringstream ex16,ex17,ex18,ex19,ex20,ex21,ex22,ex23,ex24,ex25,ex26,ex27,ex28,ex29,ex30;
230  std::stringstream ex31,ex32,ex33,ex34,ex35,ex36,ex37,ex38,ex39,ex40,ex41,ex42,ex43,ex44,ex45;
231  std::stringstream ex46,ex47,ex48,ex49,ex50,ex51,ex52,ex53,ex54,ex55,ex56,ex57,ex58,ex59,ex60;
232  std::stringstream ex61,ex62,ex63,ex64,ex65,ex66,ex67,ex68,ex69,ex70,ex71,ex72,ex73;
233  std::stringstream ex74,ex75,ex76,ex77,ex78,ex79,ex80,ex81,ex82,ex83;
234  std::stringstream ex28a,ex43a,ex70a,ex70b;
235  std::stringstream ex59a,ex59b;
236  std::stringstream ex68e;
237 
238  std::cout<<"reading tables"<<std::endl;
239 
240  std::stringstream path;
241  path << getenv("HEPFITTABS") << "/THDM/tabs/";
242  std::string tablepath=path.str();
243 
244  br1 << tablepath << "br1.dat"; /*This first matrix dummy will be deleted on Scientific Linux.*/
245  readTable(br_aa, br1.str(),19961,2);
246  br1a << tablepath << "br1.dat";
247  readTable(br_tt, br1a.str(),19961,2);
248  br2 << tablepath << "br2.dat";
249  readTable(br_bb, br2.str(),19961,2);
250  br3 << tablepath << "br3.dat";
251  readTable(br_tautau, br3.str(),19961,2);
252  br4 << tablepath << "br4.dat";
253  readTable(br_cc, br4.str(),19961,2);
254  br5 << tablepath << "br5.dat";
255  readTable(br_mumu, br5.str(),19961,2);
256  br6 << tablepath << "br6.dat";
257  readTable(br_ZZ, br6.str(),19961,2);
258  br7 << tablepath << "br7.dat";
259  readTable(br_WW, br7.str(),19961,2);
260  dw1 << tablepath << "dw1.dat";
261  readTable(GammaHtot_SM, dw1.str(),19961,2);
262  cs1 << tablepath << "log_cs_ggH_8.dat";
263  readTable(log_cs_ggH_8, cs1.str(),199,2);
264  cs11 << tablepath << "log_cs_ggH_13.dat";
265  readTable(log_cs_ggH_13, cs11.str(),199,2);
266  cs2 << tablepath << "log_cs_VBF_8.dat";
267  readTable(log_cs_VBF_8, cs2.str(),199,2);
268  cs12 << tablepath << "log_cs_VBF_13.dat";
269  readTable(log_cs_VBF_13, cs12.str(),199,2);
270  cs3 << tablepath << "log_cs_WH_8.dat";
271  readTable(log_cs_WH_8, cs3.str(),199,2);
272  cs13 << tablepath << "log_cs_WH_13.dat";
273  readTable(log_cs_WH_13, cs13.str(),199,2);
274  cs4 << tablepath << "log_cs_ZH_8.dat";
275  readTable(log_cs_ZH_8, cs4.str(),199,2);
276  cs14 << tablepath << "log_cs_ZH_13.dat";
277  readTable(log_cs_ZH_13, cs14.str(),199,2);
278  cs5 << tablepath << "log_cs_ttH_8.dat";
279  readTable(log_cs_ttH_8, cs5.str(),199,2);
280  cs15 << tablepath << "log_cs_ttH_13.dat";
281  readTable(log_cs_ttH_13, cs15.str(),199,2);
282  cs6 << tablepath << "log_cs_bbH_8.dat";
283  readTable(log_cs_bbH_8, cs6.str(),199,2);
284  cs16 << tablepath << "log_cs_bbH_13.dat";
285  readTable(log_cs_bbH_13, cs16.str(),199,2);
286  cs7 << tablepath << "log_cs_ggA_8.dat";
287  readTable(log_cs_ggA_8, cs7.str(),199,2);
288  cs17 << tablepath << "log_cs_ggA_13.dat";
289  readTable(log_cs_ggA_13, cs17.str(),199,2);
290  cs8 << tablepath << "log_cs_ttA_8.dat";
291  readTable(log_cs_ttA_8, cs8.str(),199,2);
292  cs18 << tablepath << "log_cs_ttA_13.dat";
293  readTable(log_cs_ttA_13, cs18.str(),199,2);
294  cs9 << tablepath << "log_cs_bbA_8.dat";
295  readTable(log_cs_bbA_8, cs9.str(),199,2);
296  cs19 << tablepath << "log_cs_bbA_13.dat";
297  readTable(log_cs_bbA_13, cs19.str(),199,2);
298  cs20 << tablepath << "log_cs_ggHp_8.dat";
299  readTable(log_cs_ggHp_8, cs20.str(),744,3);
300  cs21 << tablepath << "log_cs_ggHp_13.dat";
301  readTable(log_cs_ggHp_13, cs21.str(),1104,3);
302  cs22 << tablepath << "log_cs_ppH5ppH5mm_8.dat";
303  readTable(log_cs_ppH5ppH5mm_8, cs22.str(),18,2);
304  cs23 << tablepath << "log_cs_ppH5ppH5mm_13.dat";
305  readTable(log_cs_ppH5ppH5mm_13, cs23.str(),38,2);
306  cs24 << tablepath << "log_cs_VBFH5_8.dat";
307  readTable(log_cs_VBFH5_8, cs24.str(),41,2);
308  cs25 << tablepath << "log_cs_VBFH5_13.dat";
309  readTable(log_cs_VBFH5_13, cs25.str(),91,2);
310  cs26 << tablepath << "log_cs_VBFH5m_8.dat";
311  readTable(log_cs_VBFH5m_8, cs26.str(),41,2);
312  cs27 << tablepath << "log_cs_VBFH5m_13.dat";
313  readTable(log_cs_VBFH5m_13, cs27.str(),91,2);
314  cs28 << tablepath << "log_cs_VBFH5mm_8.dat";
315  readTable(log_cs_VBFH5mm_8, cs28.str(),41,2);
316  cs29 << tablepath << "log_cs_VBFH5mm_13.dat";
317  readTable(log_cs_VBFH5mm_13, cs29.str(),91,2);
318  cs30 << tablepath << "log_cs_VBFH5p_8.dat";
319  readTable(log_cs_VBFH5p_8, cs30.str(),41,2);
320  cs31 << tablepath << "log_cs_VBFH5p_13.dat";
321  readTable(log_cs_VBFH5p_13, cs31.str(),91,2);
322  cs32 << tablepath << "log_cs_VBFH5pp_8.dat";
323  readTable(log_cs_VBFH5pp_8, cs32.str(),41,2);
324  cs33 << tablepath << "log_cs_VBFH5pp_13.dat";
325  readTable(log_cs_VBFH5pp_13, cs33.str(),91,2);
326  cs34 << tablepath << "log_cs_VHH5_8.dat";
327  readTable(log_cs_VHH5_8, cs34.str(),18,2);
328  cs35 << tablepath << "log_cs_VHH5_13.dat";
329  readTable(log_cs_VHH5_13, cs35.str(),38,2);
330  cs36 << tablepath << "log_cs_VHH5mm_8.dat";
331  readTable(log_cs_VHH5mm_8, cs36.str(),18,2);
332  cs37 << tablepath << "log_cs_VHH5mm_13.dat";
333  readTable(log_cs_VHH5mm_13, cs37.str(),38,2);
334  cs38 << tablepath << "log_cs_VHH5pp_8.dat";
335  readTable(log_cs_VHH5pp_8, cs38.str(),18,2);
336  cs39 << tablepath << "log_cs_VHH5pp_13.dat";
337  readTable(log_cs_VHH5pp_13, cs39.str(),38,2);
338  ex1 << tablepath << "180711883.dat";
339  readTable(ATLAS13_tt_phi_tt, ex1.str(),61,2);
340  ex2 << tablepath << "ATLAS-CONF-2016-104_b.dat";
341  readTable(ATLAS13_bb_phi_tt, ex2.str(),61,2);
342  ex3 << tablepath << "150608329.dat";
343  readTable(CMS8_bb_phi_bb, ex3.str(),81,2);
344  ex4 << tablepath << "180206149.dat";
345  readTable(CMS8_gg_phi_bb, ex4.str(),88,2);
346  ex5 << tablepath << "CMS-PAS-HIG-16-025.dat";
347  readTable(CMS13_pp_phi_bb, ex5.str(),66,2);
348  ex6 << tablepath << "180512191.dat";
349  readTable(CMS13_bb_phi_bb, ex6.str(),101,2);
350  ex7 << tablepath << "14096064_a.dat";
351  readTable(ATLAS8_gg_phi_tautau, ex7.str(),92,2);
352  ex8 << tablepath << "CMS-PAS-HIG-14-029_a.dat";
353  readTable(CMS8_gg_phi_tautau, ex8.str(),92,2);
354  ex9 << tablepath << "14096064_b.dat";
355  readTable(ATLAS8_bb_phi_tautau, ex9.str(),92,2);
356  ex10 << tablepath << "CMS-PAS-HIG-14-029_b.dat";
357  readTable(CMS8_bb_phi_tautau, ex10.str(),92,2);
358  ex11 << tablepath << "170907242_a.dat";
359  readTable(ATLAS13_gg_phi_tautau, ex11.str(),206,2);
360  ex12 << tablepath << "180306553_a.dat";
361  readTable(CMS13_gg_phi_tautau, ex12.str(),312,2);
362  ex13 << tablepath << "170907242_b.dat";
363  readTable(ATLAS13_bb_phi_tautau, ex13.str(),206,2);
364  ex14 << tablepath << "180306553_b.dat";
365  readTable(CMS13_bb_phi_tautau, ex14.str(),312,2);
366  ex15 << tablepath << "14076583.dat";
367  readTable(ATLAS8_gg_phi_gaga, ex15.str(),108,2);
368  ex16 << tablepath << "170704147.dat";
369  readTable(ATLAS13_pp_phi_gaga, ex16.str(),251,2);
370  ex17 << tablepath << "160902507.dat";
371  readTable(CMS13_gg_phi_gaga, ex17.str(),351,2);
372  ex18 << tablepath << "14078150.dat";
373  readTable(ATLAS8_pp_phi_Zga_llga, ex18.str(),141,2);
374  ex19 << tablepath << "CMS-PAS-HIG-16-014.dat";
375  readTable(CMS8_pp_phi_Zga_llga, ex19.str(),101,2);
376  ex20 << tablepath << "170800212.dat";
377  readTable(ATLAS13_gg_phi_Zga_llga, ex20.str(),216,2);
378  ex21 << tablepath << "171203143.dat";
379  readTable(CMS13_gg_phi_Zga, ex21.str(),366,2);
380  ex22 << tablepath << "150705930_a.dat";
381  readTable(ATLAS8_gg_phi_ZZ, ex22.str(),173,2);
382  ex23 << tablepath << "150705930_b.dat";
383  readTable(ATLAS8_VV_phi_ZZ, ex23.str(),173,2);
384  ex24 << tablepath << "171206386_a.dat";
385  readTable(ATLAS13_gg_phi_ZZ_llllnunu, ex24.str(),101,2);
386  ex25 << tablepath << "171206386_b.dat";
387  readTable(ATLAS13_VV_phi_ZZ_llllnunu, ex25.str(),101,2);
388  ex26 << tablepath << "170809638_a.dat";
389  readTable(ATLAS13_gg_phi_ZZ_qqllnunu, ex26.str(),271,2);
390  ex27 << tablepath << "170809638_b.dat";
391  readTable(ATLAS13_VV_phi_ZZ_qqllnunu, ex27.str(),271,2);
392  ex28 << tablepath << "180401939_a.dat";
393  readTable(CMS13_pp_phi_ZZ_llqqnunull, ex28.str(),288,2);
394  ex28a << tablepath << "180401939_b.dat";
395  readTable(CMS13_VV_phi_ZZ_llqqnunull, ex28a.str(),288,2);
396  ex29 << tablepath << "180303838.dat";
397  readTable(CMS13_pp_phi_ZZ_qqnunu, ex29.str(),301,2);
398  ex30 << tablepath << "150900389_a.dat";
399  readTable(ATLAS8_gg_phi_WW, ex30.str(),13,2);
400  ex31 << tablepath << "150900389_b.dat";
401  readTable(ATLAS8_VV_phi_WW, ex31.str(),13,2);
402  ex32 << tablepath << "171001123_a.dat";
403  readTable(ATLAS13_gg_phi_WW_enumunu, ex32.str(),381,2);
404  ex33 << tablepath << "171001123_b.dat";
405  readTable(ATLAS13_VV_phi_WW_enumunu, ex33.str(),281,2);
406  ex34 << tablepath << "171007235_a.dat";
407  readTable(ATLAS13_gg_phi_WW_lnuqq, ex34.str(),271,2);
408  ex35 << tablepath << "171007235_b.dat";
409  readTable(ATLAS13_VV_phi_WW_lnuqq, ex35.str(),271,2);
410  ex36 << tablepath << "CMS-PAS-HIG-16-023.dat";
411  readTable(CMS13_ggVV_phi_WW_lnulnu, ex36.str(),81,2);
412  ex37 << tablepath << "180209407.dat";
413  readTable(CMS13_pp_phi_WW_lnuqq, ex37.str(),341,2);
414  ex38 << tablepath << "150400936.dat";
415  readTable(CMS8_mu_pp_phi_VV, ex38.str(),172,2);
416  ex39 << tablepath << "170804445.dat";
417  readTable(ATLAS13_pp_phi_VV_qqqq, ex39.str(),181,2);
418  ex40 << tablepath << "150904670.dat";
419  readTable(ATLAS8_gg_phi_hh, ex40.str(),75,2);
420  ex41 << tablepath << "150304114.dat";
421  readTable(CMS8_pp_phi_hh_bbbb, ex41.str(),167,2);
422  ex42 << tablepath << "160306896.dat";
423  readTable(CMS8_pp_phi_hh_gagabb, ex42.str(),85,2);
424  ex43 << tablepath << "151001181_a.dat";
425  readTable(CMS8_gg_phi_hh_bbtautau, ex43.str(),10,2);
426  ex43a << tablepath << "170700350.dat";
427  readTable(CMS8_pp_phi_hh_bbtautau, ex43a.str(),71,2);
428  ex44 << tablepath << "180406174.dat";
429  readTable(ATLAS13_pp_phi_hh_bbbb, ex44.str(),275,2);
430  ex45 << tablepath << "180603548.dat";
431  readTable(CMS13_pp_phi_hh_bbbb_1, ex45.str(),95,2);
432  ex46 << tablepath << "171004960.dat";
433  readTable(CMS13_gg_phi_hh_bbbb, ex46.str(),226,2);
434  ex47 << tablepath << "180704873.dat";
435  readTable(ATLAS13_pp_phi_hh_gagabb, ex47.str(),75,2);
436  ex48 << tablepath << "180600408.dat";
437  readTable(CMS13_pp_phi_hh_gagabb, ex48.str(),66,2);
438  ex49 << tablepath << "170702909.dat";
439  readTable(CMS13_pp_phi_hh_bbtautau_1, ex49.str(),66,2);
440  ex50 << tablepath << "170804188.dat";
441  readTable(CMS13_pp_phi_hh_bblnulnu, ex50.str(),65,2);
442  ex51 << tablepath << "180708567.dat";
443  readTable(ATLAS13_gg_phi_hh_gagaWW, ex51.str(),25,2);
444  ex52 << tablepath << "150204478_b.dat";
445  readTable(ATLAS8_gg_A_hZ_bbZ, ex52.str(),79,2);
446  ex53 << tablepath << "150404710.dat";
447  readTable(CMS8_gg_A_hZ_bbll, ex53.str(),16,2);
448  ex54 << tablepath << "150204478_a.dat";
449  readTable(ATLAS8_gg_A_hZ_tautauZ, ex54.str(),79,2);
450  ex55 << tablepath << "151001181_b.dat";
451  readTable(CMS8_gg_A_hZ_tautaull, ex55.str(),14,2);
452  ex56 << tablepath << "171206518_a.dat";
453  readTable(ATLAS13_gg_A_Zh_Zbb, ex56.str(),181,2);
454  ex57 << tablepath << "171206518_b.dat";
455  readTable(ATLAS13_bb_A_Zh_Zbb, ex57.str(),181,2);
456  ex58 << tablepath << "160302991_a.dat";
457  readTable(CMS8_pp_A_phiZ_bbll, ex58.str(),28718,3);
458  ex59 << tablepath << "160302991_b.dat";
459  readTable(CMS8_pp_phi_AZ_bbll, ex59.str(),29050,3);
460  ex59a << tablepath << "180401126_a.dat";
461  readTable(ATLAS13_gg_A_phiZ_bbll, ex59a.str(),3364,3);
462  ex59b << tablepath << "180401126_b.dat";
463  readTable(ATLAS13_bb_A_phiZ_bbll, ex59b.str(),3364,3);
464  ex60 << tablepath << "14126663.dat";
465  readTable(ATLAS8_pp_Hpm_taunu, ex60.str(),83,2);
466  ex61 << tablepath << "150807774_a.dat";
467  readTable(CMS8_pp_Hp_taunu, ex61.str(),43,2);
468  ex62 << tablepath << "180707915.dat";
469  readTable(ATLAS13_pp_Hpm_taunu, ex62.str(),192,2);
470  ex63 << tablepath << "CMS-PAS-HIG-16-031.dat";
471  readTable(CMS13_pp_Hpm_taunu, ex63.str(),283,2);
472  ex64 << tablepath << "151203704.dat";
473  readTable(ATLAS8_pp_Hpm_tb, ex64.str(),41,2);
474  ex65 << tablepath << "150807774_b.dat";
475  readTable(CMS8_pp_Hp_tb, ex65.str(),43,2);
476  ex66 << tablepath << "180803599.dat";
477  readTable(ATLAS13_pp_Hpm_tb, ex66.str(),181,2);
478  ex67 << tablepath << "150304233.dat";
479  readTable(ATLAS8_WZ_H5pm_WZ_qqll, ex67.str(),81,2);
480  ex68 << tablepath << "180601532.dat";
481  readTable(ATLAS13_WZ_H5pm_WZ_lnull, ex68.str(),71,2);
482  ex68e << tablepath << "180601532_e.dat";
483  readTable(ATLAS13_WZ_H5pm_WZ_lnull_e, ex68e.str(),15,2);
484  ex69 << tablepath << "170502942.dat";
485  readTable(CMS13_WZ_H5pm_WZ_lnull_1, ex69.str(),181,2);
486  ex70 << tablepath << "14120237_a.dat";
487  readTable(ATLAS8_pp_H5ppmmH5mmpp_eeee, ex70.str(),50,2);
488  ex70a << tablepath << "14120237_b.dat";
489  readTable(ATLAS8_pp_H5ppmmH5mmpp_emuemu, ex70a.str(),57,2);
490  ex70b << tablepath << "14120237_c.dat";
491  readTable(ATLAS8_pp_H5ppmmH5mmpp_mumumumu, ex70b.str(),57,2);
492  ex71 << tablepath << "171009748.dat";
493  readTable(ATLAS13_pp_H5ppmmH5mmpp_llll, ex71.str(),96,2);
494  ex72 << tablepath << "14106315.dat";
495  readTable(CMS8_VV_H5ppmm_WW_jjll, ex72.str(),65,2);
496  ex73 << tablepath << "170905822.dat";
497  readTable(CMS13_VV_H5ppmm_WW_jjll, ex73.str(),81,2);
498  ex74 << tablepath << "180501908.dat";
499  readTable(ATLAS13_gg_phi_Zga_qqga, ex74.str(),581,2);
500  ex75 << tablepath << "180801473.dat";
501  readTable(CMS13_pp_phi_hh_bbbb_2, ex75.str(),181,2);
502  ex76 << tablepath << "180800336.dat";
503  readTable(ATLAS13_pp_phi_hh_bbtautau, ex76.str(),75,2);
504  ex77 << tablepath << "180801365.dat";
505  readTable(CMS13_pp_phi_hh_bbtautau_2, ex77.str(),311,2);
506  ex78 << tablepath << "CMS-PAS-HIG-18-005_a.dat";
507  readTable(CMS13_gg_A_Zh_Zbb_1, ex78.str(),79,2);
508  ex79 << tablepath << "CMS-PAS-HIG-18-005_b.dat";
509  readTable(CMS13_bb_A_Zh_Zbb_1, ex79.str(),79,2);
510  ex80 << tablepath << "180702826_a.dat";
511  readTable(CMS13_gg_A_Zh_Zbb_2, ex80.str(),121,2);
512  ex81 << tablepath << "180702826_b.dat";
513  readTable(CMS13_bb_A_Zh_Zbb_2, ex81.str(),121,2);
514  ex82 << tablepath << "CMS-PAS-SMP-18-001.dat";
515  readTable(CMS13_WZ_H5pm_WZ_lnull_2, ex82.str(),171,2);
516  ex83 << tablepath << "180801899.dat";
517  readTable(ATLAS13_pp_H5ppmmH5mmpp_WWWW, ex83.str(),51,2);
518 }
519 
520 
521 
522 double GMcache::ip_Br_HPtott(double mass){
523  int NumPar = 1;
524  double params[] = {mass};
525 
526  int i = CacheCheckReal(ip_Br_HPtott_cache, NumPar, params);
527  if (i>=0) {
528  return ( ip_Br_HPtott_cache[NumPar][i] );
529  } else {
530  double newResult = pow(10.0,interpolate(br_tt,mass));
531  CacheShiftReal(ip_Br_HPtott_cache, NumPar, params, newResult);
532  return newResult;
533  }
534 }
535 
536 
537 
538 double GMcache::ip_Br_HPtobb(double mass){
539  int NumPar = 1;
540  double params[] = {mass};
541 
542  int i = CacheCheckReal(ip_Br_HPtobb_cache, NumPar, params);
543  if (i>=0) {
544  return ( ip_Br_HPtobb_cache[NumPar][i] );
545  } else {
546  double newResult = pow(10.0,interpolate(br_bb,mass));
547  CacheShiftReal(ip_Br_HPtobb_cache, NumPar, params, newResult);
548  return newResult;
549  }
550 }
551 
552 
553 
554 double GMcache::ip_Br_HPtotautau(double mass){
555  int NumPar = 1;
556  double params[] = {mass};
557 
558  int i = CacheCheckReal(ip_Br_HPtotautau_cache, NumPar, params);
559  if (i>=0) {
560  return ( ip_Br_HPtotautau_cache[NumPar][i] );
561  } else {
562  double newResult = pow(10.0,interpolate(br_tautau,mass));
563  CacheShiftReal(ip_Br_HPtotautau_cache, NumPar, params, newResult);
564  return newResult;
565  }
566 }
567 
568 
569 
570 double GMcache::ip_Br_HPtocc(double mass){
571  int NumPar = 1;
572  double params[] = {mass};
573 
574  int i = CacheCheckReal(ip_Br_HPtocc_cache, NumPar, params);
575  if (i>=0) {
576  return ( ip_Br_HPtocc_cache[NumPar][i] );
577  } else {
578  double newResult = pow(10.0,interpolate(br_cc,mass));
579  CacheShiftReal(ip_Br_HPtocc_cache, NumPar, params, newResult);
580  return newResult;
581  }
582 }
583 
584 
585 
586 double GMcache::ip_Br_HPtomumu(double mass){
587  int NumPar = 1;
588  double params[] = {mass};
589 
590  int i = CacheCheckReal(ip_Br_HPtomumu_cache, NumPar, params);
591  if (i>=0) {
592  return ( ip_Br_HPtomumu_cache[NumPar][i] );
593  } else {
594  double newResult = pow(10.0,interpolate(br_mumu,mass));
595  CacheShiftReal(ip_Br_HPtomumu_cache, NumPar, params, newResult);
596  return newResult;
597  }
598 }
599 
600 
601 
602 double GMcache::ip_Br_HPtoZZ(double mass){
603  int NumPar = 1;
604  double params[] = {mass};
605 
606  int i = CacheCheckReal(ip_Br_HPtoZZ_cache, NumPar, params);
607  if (i>=0) {
608  return ( ip_Br_HPtoZZ_cache[NumPar][i] );
609  } else {
610  double newResult = pow(10.0,interpolate(br_ZZ,mass));
611  CacheShiftReal(ip_Br_HPtoZZ_cache, NumPar, params, newResult);
612  return newResult;
613  }
614 }
615 
616 
617 
618 double GMcache::ip_Br_HPtoWW(double mass){
619  int NumPar = 1;
620  double params[] = {mass};
621 
622  int i = CacheCheckReal(ip_Br_HPtoWW_cache, NumPar, params);
623  if (i>=0) {
624  return ( ip_Br_HPtoWW_cache[NumPar][i] );
625  } else {
626  double newResult = pow(10.0,interpolate(br_WW,mass));
627  CacheShiftReal(ip_Br_HPtoWW_cache, NumPar, params, newResult);
628  return newResult;
629  }
630 }
631 
632 
633 
634 double GMcache::ip_GammaHPtotSM(double mass){
635  int NumPar = 1;
636  double params[] = {mass};
637 
638  int i = CacheCheckReal(ip_GammaHPtotSM_cache, NumPar, params);
639  if (i>=0) {
640  return ( ip_GammaHPtotSM_cache[NumPar][i] );
641  } else {
642  double newResult = pow(10.0,interpolate(GammaHtot_SM,mass));
643  CacheShiftReal(ip_GammaHPtotSM_cache, NumPar, params, newResult);
644  return newResult;
645  }
646 }
647 
648 
649 double GMcache::ip_cs_ggtoH_8(double mass){
650  int NumPar = 1;
651  double params[] = {mass};
652 
653  int i = CacheCheckReal(ip_cs_ggtoH_8_cache, NumPar, params);
654  if (i>=0) {
655  return ( ip_cs_ggtoH_8_cache[NumPar][i] );
656  } else {
657  double newResult = 0.0;
658  if (mass>=20. && mass <=2000.) {
659  newResult = pow(10.0,interpolate(log_cs_ggH_8,mass));
660  }
661  CacheShiftReal(ip_cs_ggtoH_8_cache, NumPar, params, newResult);
662  return newResult;
663  }
664 }
665 
666 
667 
668 double GMcache::ip_cs_ggtoH_13(double mass){
669  int NumPar = 1;
670  double params[] = {mass};
671 
672  int i = CacheCheckReal(ip_cs_ggtoH_13_cache, NumPar, params);
673  if (i>=0) {
674  return ( ip_cs_ggtoH_13_cache[NumPar][i] );
675  } else {
676  double newResult = 0.0;
677  if (mass>=20. && mass <=2000.) {
678  newResult = pow(10.0,interpolate(log_cs_ggH_13,mass));
679  }
680  CacheShiftReal(ip_cs_ggtoH_13_cache, NumPar, params, newResult);
681  return newResult;
682  }
683 }
684 
685 
686 
687 double GMcache::ip_cs_VBFtoH_8(double mass){
688  int NumPar = 1;
689  double params[] = {mass};
690 
691  int i = CacheCheckReal(ip_cs_VBFtoH_8_cache, NumPar, params);
692  if (i>=0) {
693  return ( ip_cs_VBFtoH_8_cache[NumPar][i] );
694  } else {
695  double newResult = 0.0;
696  if (mass>=20. && mass <=2000.) {
697  newResult = pow(10.0,interpolate(log_cs_VBF_8,mass));
698  }
699  CacheShiftReal(ip_cs_VBFtoH_8_cache, NumPar, params, newResult);
700  return newResult;
701  }
702 }
703 
704 
705 
706 double GMcache::ip_cs_VBFtoH_13(double mass){
707  int NumPar = 1;
708  double params[] = {mass};
709 
710  int i = CacheCheckReal(ip_cs_VBFtoH_13_cache, NumPar, params);
711  if (i>=0) {
712  return ( ip_cs_VBFtoH_13_cache[NumPar][i] );
713  } else {
714  double newResult = 0.0;
715  if (mass>=20. && mass <=2000.) {
716  newResult = pow(10.0,interpolate(log_cs_VBF_13,mass));
717  }
718  CacheShiftReal(ip_cs_VBFtoH_13_cache, NumPar, params, newResult);
719  return newResult;
720  }
721 }
722 
723 
724 
725 double GMcache::ip_cs_WtoWH_8(double mass){
726  int NumPar = 1;
727  double params[] = {mass};
728 
729  int i = CacheCheckReal(ip_cs_WtoWH_8_cache, NumPar, params);
730  if (i>=0) {
731  return ( ip_cs_WtoWH_8_cache[NumPar][i] );
732  } else {
733  double newResult = 0.0;
734  if (mass>=20. && mass <=2000.) {
735  newResult = pow(10.0,interpolate(log_cs_WH_8,mass));
736  }
737  CacheShiftReal(ip_cs_WtoWH_8_cache, NumPar, params, newResult);
738  return newResult;
739  }
740 }
741 
742 
743 
744 double GMcache::ip_cs_WtoWH_13(double mass){
745  int NumPar = 1;
746  double params[] = {mass};
747 
748  int i = CacheCheckReal(ip_cs_WtoWH_13_cache, NumPar, params);
749  if (i>=0) {
750  return ( ip_cs_WtoWH_13_cache[NumPar][i] );
751  } else {
752  double newResult = 0.0;
753  if (mass>=20. && mass <=2000.) {
754  newResult = pow(10.0,interpolate(log_cs_WH_13,mass));
755  }
756  CacheShiftReal(ip_cs_WtoWH_13_cache, NumPar, params, newResult);
757  return newResult;
758  }
759 }
760 
761 
762 
763 double GMcache::ip_cs_ZtoZH_8(double mass){
764  int NumPar = 1;
765  double params[] = {mass};
766 
767  int i = CacheCheckReal(ip_cs_ZtoZH_8_cache, NumPar, params);
768  if (i>=0) {
769  return ( ip_cs_ZtoZH_8_cache[NumPar][i] );
770  } else {
771  double newResult = 0.0;
772  if (mass>=20. && mass <=2000.) {
773  newResult = pow(10.0,interpolate(log_cs_ZH_8,mass));
774  }
775  CacheShiftReal(ip_cs_ZtoZH_8_cache, NumPar, params, newResult);
776  return newResult;
777  }
778 }
779 
780 
781 
782 double GMcache::ip_cs_ZtoZH_13(double mass){
783  int NumPar = 1;
784  double params[] = {mass};
785 
786  int i = CacheCheckReal(ip_cs_ZtoZH_13_cache, NumPar, params);
787  if (i>=0) {
788  return ( ip_cs_ZtoZH_13_cache[NumPar][i] );
789  } else {
790  double newResult = 0.0;
791  if (mass>=20. && mass <=2000.) {
792  newResult = pow(10.0,interpolate(log_cs_ZH_13,mass));
793  }
794  CacheShiftReal(ip_cs_ZtoZH_13_cache, NumPar, params, newResult);
795  return newResult;
796  }
797 }
798 
799 
800 
801 double GMcache::ip_cs_pptottH_8(double mass){
802  int NumPar = 1;
803  double params[] = {mass};
804 
805  int i = CacheCheckReal(ip_cs_pptottH_8_cache, NumPar, params);
806  if (i>=0) {
807  return ( ip_cs_pptottH_8_cache[NumPar][i] );
808  } else {
809  double newResult = 0.0;
810  if (mass>=20. && mass <=2000.) {
811  newResult = pow(10.0,interpolate(log_cs_ttH_8,mass));
812  }
813  CacheShiftReal(ip_cs_pptottH_8_cache, NumPar, params, newResult);
814  return newResult;
815  }
816 }
817 
818 
819 
820 double GMcache::ip_cs_pptottH_13(double mass){
821  int NumPar = 1;
822  double params[] = {mass};
823 
824  int i = CacheCheckReal(ip_cs_pptottH_13_cache, NumPar, params);
825  if (i>=0) {
826  return ( ip_cs_pptottH_13_cache[NumPar][i] );
827  } else {
828  double newResult = 0.0;
829  if (mass>=20. && mass <=2000.) {
830  newResult = pow(10.0,interpolate(log_cs_ttH_13,mass));
831  }
832  CacheShiftReal(ip_cs_pptottH_13_cache, NumPar, params, newResult);
833  return newResult;
834  }
835 }
836 
837 
838 
839 double GMcache::ip_cs_pptobbH_8(double mass){
840  int NumPar = 1;
841  double params[] = {mass};
842 
843  int i = CacheCheckReal(ip_cs_pptobbH_8_cache, NumPar, params);
844  if (i>=0) {
845  return ( ip_cs_pptobbH_8_cache[NumPar][i] );
846  } else {
847  double newResult = 0.0;
848  if (mass>=20. && mass <=2000.) {
849  newResult = pow(10.0,interpolate(log_cs_bbH_8,mass));
850  }
851  CacheShiftReal(ip_cs_pptobbH_8_cache, NumPar, params, newResult);
852  return newResult;
853  }
854 }
855 
856 
857 
858 double GMcache::ip_cs_pptobbH_13(double mass){
859  int NumPar = 1;
860  double params[] = {mass};
861 
862  int i = CacheCheckReal(ip_cs_pptobbH_13_cache, NumPar, params);
863  if (i>=0) {
864  return ( ip_cs_pptobbH_13_cache[NumPar][i] );
865  } else {
866  double newResult = 0.0;
867  if (mass>=20. && mass <=2000.) {
868  newResult = pow(10.0,interpolate(log_cs_bbH_13,mass));
869  }
870  CacheShiftReal(ip_cs_pptobbH_13_cache, NumPar, params, newResult);
871  return newResult;
872  }
873 }
874 
875 
876 
877 double GMcache::ip_cs_ggtoA_8(double mass){
878  int NumPar = 1;
879  double params[] = {mass};
880 
881  int i = CacheCheckReal(ip_cs_ggtoA_8_cache, NumPar, params);
882  if (i>=0) {
883  return ( ip_cs_ggtoA_8_cache[NumPar][i] );
884  } else {
885  double newResult = 0.0;
886  if (mass>=20. && mass <=2000.) {
887  newResult = pow(10.0,interpolate(log_cs_ggA_8,mass));
888  }
889  CacheShiftReal(ip_cs_ggtoA_8_cache, NumPar, params, newResult);
890  return newResult;
891  }
892 }
893 
894 
895 
896 double GMcache::ip_cs_ggtoA_13(double mass){
897  int NumPar = 1;
898  double params[] = {mass};
899 
900  int i = CacheCheckReal(ip_cs_ggtoA_13_cache, NumPar, params);
901  if (i>=0) {
902  return ( ip_cs_ggtoA_13_cache[NumPar][i] );
903  } else {
904  double newResult = 0.0;
905  if (mass>=20. && mass <=2000.) {
906  newResult = pow(10.0,interpolate(log_cs_ggA_13,mass));
907  }
908  CacheShiftReal(ip_cs_ggtoA_13_cache, NumPar, params, newResult);
909  return newResult;
910  }
911 }
912 
913 
914 
915 double GMcache::ip_cs_pptottA_8(double mass){
916  int NumPar = 1;
917  double params[] = {mass};
918 
919  int i = CacheCheckReal(ip_cs_pptottA_8_cache, NumPar, params);
920  if (i>=0) {
921  return ( ip_cs_pptottA_8_cache[NumPar][i] );
922  } else {
923  double newResult = 0.0;
924  if (mass>=20. && mass <=2000.) {
925  newResult = pow(10.0,interpolate(log_cs_ttA_8,mass));
926  }
927  CacheShiftReal(ip_cs_pptottA_8_cache, NumPar, params, newResult);
928  return newResult;
929  }
930 }
931 
932 
933 
934 double GMcache::ip_cs_pptottA_13(double mass){
935  int NumPar = 1;
936  double params[] = {mass};
937 
938  int i = CacheCheckReal(ip_cs_pptottA_13_cache, NumPar, params);
939  if (i>=0) {
940  return ( ip_cs_pptottA_13_cache[NumPar][i] );
941  } else {
942  double newResult = 0.0;
943  if (mass>=20. && mass <=2000.) {
944  newResult = pow(10.0,interpolate(log_cs_ttA_13,mass));
945  }
946  CacheShiftReal(ip_cs_pptottA_13_cache, NumPar, params, newResult);
947  return newResult;
948  }
949 }
950 
951 
952 
953 double GMcache::ip_cs_pptobbA_8(double mass){
954  int NumPar = 1;
955  double params[] = {mass};
956 
957  int i = CacheCheckReal(ip_cs_pptobbA_8_cache, NumPar, params);
958  if (i>=0) {
959  return ( ip_cs_pptobbA_8_cache[NumPar][i] );
960  } else {
961  double newResult = 0.0;
962  if (mass>=20. && mass <=2000.) {
963  newResult = pow(10.0,interpolate(log_cs_bbA_8,mass));
964  }
965  CacheShiftReal(ip_cs_pptobbA_8_cache, NumPar, params, newResult);
966  return newResult;
967  }
968 }
969 
970 
971 
972 double GMcache::ip_cs_pptobbA_13(double mass){
973  int NumPar = 1;
974  double params[] = {mass};
975 
976  int i = CacheCheckReal(ip_cs_pptobbA_13_cache, NumPar, params);
977  if (i>=0) {
978  return ( ip_cs_pptobbA_13_cache[NumPar][i] );
979  } else {
980  double newResult = 0.0;
981  if (mass>=20. && mass <=2000.) {
982  newResult = pow(10.0,interpolate(log_cs_bbA_13,mass));
983  }
984  CacheShiftReal(ip_cs_pptobbA_13_cache, NumPar, params, newResult);
985  return newResult;
986  }
987 }
988 
989 
990 
991 double GMcache::ip_cs_ggtoHp_8(double mHp, double logtb){
992  int NumPar = 2;
993  double params[] = {mHp, logtb};
994 
995  int i = CacheCheckReal(ip_cs_ggtoHp_8_cache, NumPar, params);
996  if (i>=0) {
997  return ( ip_cs_ggtoHp_8_cache[NumPar][i] );
998  } else {
999  double newResult = 0.0;
1000  if (mHp>=180. && mHp <=1400. && logtb>=-1. && logtb<=1.75) {
1001  newResult = pow(10.0,interpolate2D(log_cs_ggHp_8, logtb, mHp));
1002  }
1003  CacheShiftReal(ip_cs_ggtoHp_8_cache, NumPar, params, newResult);
1004  return newResult;
1005  }
1006 }
1007 
1008 
1009 
1010 double GMcache::ip_cs_ggtoHp_13(double mHp, double logtb){
1011  int NumPar = 2;
1012  double params[] = {mHp, logtb};
1013 
1014  int i = CacheCheckReal(ip_cs_ggtoHp_13_cache, NumPar, params);
1015  if (i>=0) {
1016  return ( ip_cs_ggtoHp_13_cache[NumPar][i] );
1017  } else {
1018  double newResult = 0.0;
1019  if (mHp>=180. && mHp <=2000. && logtb>=-1. && logtb<=1.75) {
1020  newResult = pow(10.0,interpolate2D(log_cs_ggHp_13, logtb, mHp));
1021  }
1022  CacheShiftReal(ip_cs_ggtoHp_13_cache, NumPar, params, newResult);
1023  return newResult;
1024  }
1025 }
1026 
1027 
1028 
1029 double GMcache::ip_cs_ppH5ppH5mm_8(double mass){
1030  int NumPar = 1;
1031  double params[] = {mass};
1032 
1033  int i = CacheCheckReal(ip_cs_ppH5ppH5mm_8_cache, NumPar, params);
1034  if (i>=0) {
1035  return ( ip_cs_ppH5ppH5mm_8_cache[NumPar][i] );
1036  } else {
1037  double newResult = 0.0;
1038  if (mass>=150. && mass <=1000.) {
1039  newResult = pow(10.0,interpolate(log_cs_ppH5ppH5mm_8,mass));
1040  }
1041  CacheShiftReal(ip_cs_ppH5ppH5mm_8_cache, NumPar, params, newResult);
1042  return newResult;
1043  }
1044 }
1045 
1046 
1047 
1048 double GMcache::ip_cs_ppH5ppH5mm_13(double mass){
1049  int NumPar = 1;
1050  double params[] = {mass};
1051 
1052  int i = CacheCheckReal(ip_cs_ppH5ppH5mm_13_cache, NumPar, params);
1053  if (i>=0) {
1054  return ( ip_cs_ppH5ppH5mm_13_cache[NumPar][i] );
1055  } else {
1056  double newResult = 0.0;
1057  if (mass>=150. && mass <=2000.) {
1058  newResult = pow(10.0,interpolate(log_cs_ppH5ppH5mm_13,mass));
1059  }
1060  CacheShiftReal(ip_cs_ppH5ppH5mm_13_cache, NumPar, params, newResult);
1061  return newResult;
1062  }
1063 }
1064 
1065 
1066 
1067 double GMcache::ip_cs_VBFH5_8(double mass){
1068  int NumPar = 1;
1069  double params[] = {mass};
1070 
1071  int i = CacheCheckReal(ip_cs_VBFH5_8_cache, NumPar, params);
1072  if (i>=0) {
1073  return ( ip_cs_VBFH5_8_cache[NumPar][i] );
1074  } else {
1075  double newResult = 0.0;
1076  if (mass>=200. && mass <=1000.) {
1077  newResult = pow(10.0,interpolate(log_cs_VBFH5_8,mass));
1078  }
1079  CacheShiftReal(ip_cs_VBFH5_8_cache, NumPar, params, newResult);
1080  return newResult;
1081  }
1082 }
1083 
1084 
1085 
1086 double GMcache::ip_cs_VBFH5_13(double mass){
1087  int NumPar = 1;
1088  double params[] = {mass};
1089 
1090  int i = CacheCheckReal(ip_cs_VBFH5_13_cache, NumPar, params);
1091  if (i>=0) {
1092  return ( ip_cs_VBFH5_13_cache[NumPar][i] );
1093  } else {
1094  double newResult = 0.0;
1095  if (mass>=200. && mass <=2000.) {
1096  newResult = pow(10.0,interpolate(log_cs_VBFH5_13,mass));
1097  }
1098  CacheShiftReal(ip_cs_VBFH5_13_cache, NumPar, params, newResult);
1099  return newResult;
1100  }
1101 }
1102 
1103 
1104 
1105 double GMcache::ip_cs_VBFH5m_8(double mass){
1106  int NumPar = 1;
1107  double params[] = {mass};
1108 
1109  int i = CacheCheckReal(ip_cs_VBFH5m_8_cache, NumPar, params);
1110  if (i>=0) {
1111  return ( ip_cs_VBFH5m_8_cache[NumPar][i] );
1112  } else {
1113  double newResult = 0.0;
1114  if (mass>=200. && mass <=1000.) {
1115  newResult = pow(10.0,interpolate(log_cs_VBFH5m_8,mass));
1116  }
1117  CacheShiftReal(ip_cs_VBFH5m_8_cache, NumPar, params, newResult);
1118  return newResult;
1119  }
1120 }
1121 
1122 
1123 
1124 double GMcache::ip_cs_VBFH5m_13(double mass){
1125  int NumPar = 1;
1126  double params[] = {mass};
1127 
1128  int i = CacheCheckReal(ip_cs_VBFH5m_13_cache, NumPar, params);
1129  if (i>=0) {
1130  return ( ip_cs_VBFH5m_13_cache[NumPar][i] );
1131  } else {
1132  double newResult = 0.0;
1133  if (mass>=200. && mass <=2000.) {
1134  newResult = pow(10.0,interpolate(log_cs_VBFH5m_13,mass));
1135  }
1136  CacheShiftReal(ip_cs_VBFH5m_13_cache, NumPar, params, newResult);
1137  return newResult;
1138  }
1139 }
1140 
1141 
1142 
1143 double GMcache::ip_cs_VBFH5mm_8(double mass){
1144  int NumPar = 1;
1145  double params[] = {mass};
1146 
1147  int i = CacheCheckReal(ip_cs_VBFH5mm_8_cache, NumPar, params);
1148  if (i>=0) {
1149  return ( ip_cs_VBFH5mm_8_cache[NumPar][i] );
1150  } else {
1151  double newResult = 0.0;
1152  if (mass>=200. && mass <=1000.) {
1153  newResult = pow(10.0,interpolate(log_cs_VBFH5mm_8,mass));
1154  }
1155  CacheShiftReal(ip_cs_VBFH5mm_8_cache, NumPar, params, newResult);
1156  return newResult;
1157  }
1158 }
1159 
1160 
1161 
1162 double GMcache::ip_cs_VBFH5mm_13(double mass){
1163  int NumPar = 1;
1164  double params[] = {mass};
1165 
1166  int i = CacheCheckReal(ip_cs_VBFH5mm_13_cache, NumPar, params);
1167  if (i>=0) {
1168  return ( ip_cs_VBFH5mm_13_cache[NumPar][i] );
1169  } else {
1170  double newResult = 0.0;
1171  if (mass>=200. && mass <=2000.) {
1172  newResult = pow(10.0,interpolate(log_cs_VBFH5mm_13,mass));
1173  }
1174  CacheShiftReal(ip_cs_VBFH5mm_13_cache, NumPar, params, newResult);
1175  return newResult;
1176  }
1177 }
1178 
1179 
1180 
1181 double GMcache::ip_cs_VBFH5p_8(double mass){
1182  int NumPar = 1;
1183  double params[] = {mass};
1184 
1185  int i = CacheCheckReal(ip_cs_VBFH5p_8_cache, NumPar, params);
1186  if (i>=0) {
1187  return ( ip_cs_VBFH5p_8_cache[NumPar][i] );
1188  } else {
1189  double newResult = 0.0;
1190  if (mass>=200. && mass <=1000.) {
1191  newResult = pow(10.0,interpolate(log_cs_VBFH5p_8,mass));
1192  }
1193  CacheShiftReal(ip_cs_VBFH5p_8_cache, NumPar, params, newResult);
1194  return newResult;
1195  }
1196 }
1197 
1198 
1199 
1200 double GMcache::ip_cs_VBFH5p_13(double mass){
1201  int NumPar = 1;
1202  double params[] = {mass};
1203 
1204  int i = CacheCheckReal(ip_cs_VBFH5p_13_cache, NumPar, params);
1205  if (i>=0) {
1206  return ( ip_cs_VBFH5p_13_cache[NumPar][i] );
1207  } else {
1208  double newResult = 0.0;
1209  if (mass>=200. && mass <=2000.) {
1210  newResult = pow(10.0,interpolate(log_cs_VBFH5p_13,mass));
1211  }
1212  CacheShiftReal(ip_cs_VBFH5p_13_cache, NumPar, params, newResult);
1213  return newResult;
1214  }
1215 }
1216 
1217 
1218 
1219 double GMcache::ip_cs_VBFH5pp_8(double mass){
1220  int NumPar = 1;
1221  double params[] = {mass};
1222 
1223  int i = CacheCheckReal(ip_cs_VBFH5pp_8_cache, NumPar, params);
1224  if (i>=0) {
1225  return ( ip_cs_VBFH5pp_8_cache[NumPar][i] );
1226  } else {
1227  double newResult = 0.0;
1228  if (mass>=200. && mass <=1000.) {
1229  newResult = pow(10.0,interpolate(log_cs_VBFH5pp_8,mass));
1230  }
1231  CacheShiftReal(ip_cs_VBFH5pp_8_cache, NumPar, params, newResult);
1232  return newResult;
1233  }
1234 }
1235 
1236 
1237 
1238 double GMcache::ip_cs_VBFH5pp_13(double mass){
1239  int NumPar = 1;
1240  double params[] = {mass};
1241 
1242  int i = CacheCheckReal(ip_cs_VBFH5pp_13_cache, NumPar, params);
1243  if (i>=0) {
1244  return ( ip_cs_VBFH5pp_13_cache[NumPar][i] );
1245  } else {
1246  double newResult = 0.0;
1247  if (mass>=200. && mass <=2000.) {
1248  newResult = pow(10.0,interpolate(log_cs_VBFH5pp_13,mass));
1249  }
1250  CacheShiftReal(ip_cs_VBFH5pp_13_cache, NumPar, params, newResult);
1251  return newResult;
1252  }
1253 }
1254 
1255 
1256 
1257 double GMcache::ip_cs_VHH5_8(double mass){
1258  int NumPar = 1;
1259  double params[] = {mass};
1260 
1261  int i = CacheCheckReal(ip_cs_VHH5_8_cache, NumPar, params);
1262  if (i>=0) {
1263  return ( ip_cs_VHH5_8_cache[NumPar][i] );
1264  } else {
1265  double newResult = 0.0;
1266  if (mass>=150. && mass <=1000.) {
1267  newResult = pow(10.0,interpolate(log_cs_VHH5_8,mass));
1268  }
1269  CacheShiftReal(ip_cs_VHH5_8_cache, NumPar, params, newResult);
1270  return newResult;
1271  }
1272 }
1273 
1274 
1275 
1276 double GMcache::ip_cs_VHH5_13(double mass){
1277  int NumPar = 1;
1278  double params[] = {mass};
1279 
1280  int i = CacheCheckReal(ip_cs_VHH5_13_cache, NumPar, params);
1281  if (i>=0) {
1282  return ( ip_cs_VHH5_13_cache[NumPar][i] );
1283  } else {
1284  double newResult = 0.0;
1285  if (mass>=150. && mass <=2000.) {
1286  newResult = pow(10.0,interpolate(log_cs_VHH5_13,mass));
1287  }
1288  CacheShiftReal(ip_cs_VHH5_13_cache, NumPar, params, newResult);
1289  return newResult;
1290  }
1291 }
1292 
1293 
1294 
1295 double GMcache::ip_cs_VHH5mm_8(double mass){
1296  int NumPar = 1;
1297  double params[] = {mass};
1298 
1299  int i = CacheCheckReal(ip_cs_VHH5mm_8_cache, NumPar, params);
1300  if (i>=0) {
1301  return ( ip_cs_VHH5mm_8_cache[NumPar][i] );
1302  } else {
1303  double newResult = 0.0;
1304  if (mass>=150. && mass <=1000.) {
1305  newResult = pow(10.0,interpolate(log_cs_VHH5mm_8,mass));
1306  }
1307  CacheShiftReal(ip_cs_VHH5mm_8_cache, NumPar, params, newResult);
1308  return newResult;
1309  }
1310 }
1311 
1312 
1313 
1314 double GMcache::ip_cs_VHH5mm_13(double mass){
1315  int NumPar = 1;
1316  double params[] = {mass};
1317 
1318  int i = CacheCheckReal(ip_cs_VHH5mm_13_cache, NumPar, params);
1319  if (i>=0) {
1320  return ( ip_cs_VHH5mm_13_cache[NumPar][i] );
1321  } else {
1322  double newResult = 0.0;
1323  if (mass>=150. && mass <=2000.) {
1324  newResult = pow(10.0,interpolate(log_cs_VHH5mm_13,mass));
1325  }
1326  CacheShiftReal(ip_cs_VHH5mm_13_cache, NumPar, params, newResult);
1327  return newResult;
1328  }
1329 }
1330 
1331 
1332 
1333 double GMcache::ip_cs_VHH5pp_8(double mass){
1334  int NumPar = 1;
1335  double params[] = {mass};
1336 
1337  int i = CacheCheckReal(ip_cs_VHH5pp_8_cache, NumPar, params);
1338  if (i>=0) {
1339  return ( ip_cs_VHH5pp_8_cache[NumPar][i] );
1340  } else {
1341  double newResult = 0.0;
1342  if (mass>=150. && mass <=1000.) {
1343  newResult = pow(10.0,interpolate(log_cs_VHH5pp_8,mass));
1344  }
1345  CacheShiftReal(ip_cs_VHH5pp_8_cache, NumPar, params, newResult);
1346  return newResult;
1347  }
1348 }
1349 
1350 
1351 
1352 double GMcache::ip_cs_VHH5pp_13(double mass){
1353  int NumPar = 1;
1354  double params[] = {mass};
1355 
1356  int i = CacheCheckReal(ip_cs_VHH5pp_13_cache, NumPar, params);
1357  if (i>=0) {
1358  return ( ip_cs_VHH5pp_13_cache[NumPar][i] );
1359  } else {
1360  double newResult = 0.0;
1361  if (mass>=150. && mass <=2000.) {
1362  newResult = pow(10.0,interpolate(log_cs_VHH5pp_13,mass));
1363  }
1364  CacheShiftReal(ip_cs_VHH5pp_13_cache, NumPar, params, newResult);
1365  return newResult;
1366  }
1367 }
1368 
1369 
1370 
1371 double GMcache::ip_ex_tt_phi_tt_ATLAS13(double mass){
1372  int NumPar = 1;
1373  double params[] = {mass};
1374 
1375  int i = CacheCheckReal(ip_ex_tt_phi_tt_ATLAS13_cache, NumPar, params);
1376  if (i>=0) {
1377  return ( ip_ex_tt_phi_tt_ATLAS13_cache[NumPar][i] );
1378  } else {
1379  double newResult = interpolate(ATLAS13_tt_phi_tt,mass);
1380  CacheShiftReal(ip_ex_tt_phi_tt_ATLAS13_cache, NumPar, params, newResult);
1381  return newResult;
1382  }
1383 }
1384 
1385 double GMcache::ip_ex_bb_phi_tt_ATLAS13(double mass){
1386  int NumPar = 1;
1387  double params[] = {mass};
1388 
1389  int i = CacheCheckReal(ip_ex_bb_phi_tt_ATLAS13_cache, NumPar, params);
1390  if (i>=0) {
1391  return ( ip_ex_bb_phi_tt_ATLAS13_cache[NumPar][i] );
1392  } else {
1393  double newResult = interpolate(ATLAS13_bb_phi_tt,mass);
1394  CacheShiftReal(ip_ex_bb_phi_tt_ATLAS13_cache, NumPar, params, newResult);
1395  return newResult;
1396  }
1397 }
1398 
1399 double GMcache::ip_ex_bb_phi_bb_CMS8(double mass){
1400  int NumPar = 1;
1401  double params[] = {mass};
1402 
1403  int i = CacheCheckReal(ip_ex_bb_phi_bb_CMS8_cache, NumPar, params);
1404  if (i>=0) {
1405  return ( ip_ex_bb_phi_bb_CMS8_cache[NumPar][i] );
1406  } else {
1407  double newResult = interpolate(CMS8_bb_phi_bb,mass);
1408  CacheShiftReal(ip_ex_bb_phi_bb_CMS8_cache, NumPar, params, newResult);
1409  return newResult;
1410  }
1411 }
1412 
1413 double GMcache::ip_ex_gg_phi_bb_CMS8(double mass){
1414  int NumPar = 1;
1415  double params[] = {mass};
1416 
1417  int i = CacheCheckReal(ip_ex_gg_phi_bb_CMS8_cache, NumPar, params);
1418  if (i>=0) {
1419  return ( ip_ex_gg_phi_bb_CMS8_cache[NumPar][i] );
1420  } else {
1421  double newResult = interpolate(CMS8_gg_phi_bb,mass);
1422  CacheShiftReal(ip_ex_gg_phi_bb_CMS8_cache, NumPar, params, newResult);
1423  return newResult;
1424  }
1425 }
1426 
1427 double GMcache::ip_ex_pp_phi_bb_CMS13(double mass){
1428  int NumPar = 1;
1429  double params[] = {mass};
1430 
1431  int i = CacheCheckReal(ip_ex_pp_phi_bb_CMS13_cache, NumPar, params);
1432  if (i>=0) {
1433  return ( ip_ex_pp_phi_bb_CMS13_cache[NumPar][i] );
1434  } else {
1435  double newResult = interpolate(CMS13_pp_phi_bb,mass);
1436  CacheShiftReal(ip_ex_pp_phi_bb_CMS13_cache, NumPar, params, newResult);
1437  return newResult;
1438  }
1439 }
1440 
1441 double GMcache::ip_ex_bb_phi_bb_CMS13(double mass){
1442  int NumPar = 1;
1443  double params[] = {mass};
1444 
1445  int i = CacheCheckReal(ip_ex_bb_phi_bb_CMS13_cache, NumPar, params);
1446  if (i>=0) {
1447  return ( ip_ex_bb_phi_bb_CMS13_cache[NumPar][i] );
1448  } else {
1449  double newResult = interpolate(CMS13_bb_phi_bb,mass);
1450  CacheShiftReal(ip_ex_bb_phi_bb_CMS13_cache, NumPar, params, newResult);
1451  return newResult;
1452  }
1453 }
1454 
1455 double GMcache::ip_ex_gg_phi_tautau_ATLAS8(double mass){
1456  int NumPar = 1;
1457  double params[] = {mass};
1458 
1459  int i = CacheCheckReal(ip_ex_gg_phi_tautau_ATLAS8_cache, NumPar, params);
1460  if (i>=0) {
1461  return ( ip_ex_gg_phi_tautau_ATLAS8_cache[NumPar][i] );
1462  } else {
1463  double newResult = interpolate(ATLAS8_gg_phi_tautau,mass);
1464  CacheShiftReal(ip_ex_gg_phi_tautau_ATLAS8_cache, NumPar, params, newResult);
1465  return newResult;
1466  }
1467 }
1468 
1469 double GMcache::ip_ex_gg_phi_tautau_CMS8(double mass){
1470  int NumPar = 1;
1471  double params[] = {mass};
1472 
1473  int i = CacheCheckReal(ip_ex_gg_phi_tautau_CMS8_cache, NumPar, params);
1474  if (i>=0) {
1475  return ( ip_ex_gg_phi_tautau_CMS8_cache[NumPar][i] );
1476  } else {
1477  double newResult = interpolate(CMS8_gg_phi_tautau,mass);
1478  CacheShiftReal(ip_ex_gg_phi_tautau_CMS8_cache, NumPar, params, newResult);
1479  return newResult;
1480  }
1481 }
1482 
1483 double GMcache::ip_ex_bb_phi_tautau_ATLAS8(double mass){
1484  int NumPar = 1;
1485  double params[] = {mass};
1486 
1487  int i = CacheCheckReal(ip_ex_bb_phi_tautau_ATLAS8_cache, NumPar, params);
1488  if (i>=0) {
1489  return ( ip_ex_bb_phi_tautau_ATLAS8_cache[NumPar][i] );
1490  } else {
1491  double newResult = interpolate(ATLAS8_bb_phi_tautau,mass);
1492  CacheShiftReal(ip_ex_bb_phi_tautau_ATLAS8_cache, NumPar, params, newResult);
1493  return newResult;
1494  }
1495 }
1496 
1497 double GMcache::ip_ex_bb_phi_tautau_CMS8(double mass){
1498  int NumPar = 1;
1499  double params[] = {mass};
1500 
1501  int i = CacheCheckReal(ip_ex_bb_phi_tautau_CMS8_cache, NumPar, params);
1502  if (i>=0) {
1503  return ( ip_ex_bb_phi_tautau_CMS8_cache[NumPar][i] );
1504  } else {
1505  double newResult = interpolate(CMS8_bb_phi_tautau,mass);
1506  CacheShiftReal(ip_ex_bb_phi_tautau_CMS8_cache, NumPar, params, newResult);
1507  return newResult;
1508  }
1509 }
1510 
1511 double GMcache::ip_ex_gg_phi_tautau_ATLAS13(double mass){
1512  int NumPar = 1;
1513  double params[] = {mass};
1514 
1515  int i = CacheCheckReal(ip_ex_gg_phi_tautau_ATLAS13_cache, NumPar, params);
1516  if (i>=0) {
1517  return ( ip_ex_gg_phi_tautau_ATLAS13_cache[NumPar][i] );
1518  } else {
1519  double newResult = interpolate(ATLAS13_gg_phi_tautau,mass);
1520  CacheShiftReal(ip_ex_gg_phi_tautau_ATLAS13_cache, NumPar, params, newResult);
1521  return newResult;
1522  }
1523 }
1524 
1525 double GMcache::ip_ex_gg_phi_tautau_CMS13(double mass){
1526  int NumPar = 1;
1527  double params[] = {mass};
1528 
1529  int i = CacheCheckReal(ip_ex_gg_phi_tautau_CMS13_cache, NumPar, params);
1530  if (i>=0) {
1531  return ( ip_ex_gg_phi_tautau_CMS13_cache[NumPar][i] );
1532  } else {
1533  double newResult = interpolate(CMS13_gg_phi_tautau,mass);
1534  CacheShiftReal(ip_ex_gg_phi_tautau_CMS13_cache, NumPar, params, newResult);
1535  return newResult;
1536  }
1537 }
1538 
1539 double GMcache::ip_ex_bb_phi_tautau_ATLAS13(double mass){
1540  int NumPar = 1;
1541  double params[] = {mass};
1542 
1543  int i = CacheCheckReal(ip_ex_bb_phi_tautau_ATLAS13_cache, NumPar, params);
1544  if (i>=0) {
1545  return ( ip_ex_bb_phi_tautau_ATLAS13_cache[NumPar][i] );
1546  } else {
1547  double newResult = interpolate(ATLAS13_bb_phi_tautau,mass);
1548  CacheShiftReal(ip_ex_bb_phi_tautau_ATLAS13_cache, NumPar, params, newResult);
1549  return newResult;
1550  }
1551 }
1552 
1553 double GMcache::ip_ex_bb_phi_tautau_CMS13(double mass){
1554  int NumPar = 1;
1555  double params[] = {mass};
1556 
1557  int i = CacheCheckReal(ip_ex_bb_phi_tautau_CMS13_cache, NumPar, params);
1558  if (i>=0) {
1559  return ( ip_ex_bb_phi_tautau_CMS13_cache[NumPar][i] );
1560  } else {
1561  double newResult = interpolate(CMS13_bb_phi_tautau,mass);
1562  CacheShiftReal(ip_ex_bb_phi_tautau_CMS13_cache, NumPar, params, newResult);
1563  return newResult;
1564  }
1565 }
1566 
1567 double GMcache::ip_ex_gg_phi_gaga_ATLAS8(double mass){
1568  int NumPar = 1;
1569  double params[] = {mass};
1570 
1571  int i = CacheCheckReal(ip_ex_gg_phi_gaga_ATLAS8_cache, NumPar, params);
1572  if (i>=0) {
1573  return ( ip_ex_gg_phi_gaga_ATLAS8_cache[NumPar][i] );
1574  } else {
1575  double newResult = interpolate(ATLAS8_gg_phi_gaga,mass);
1576  CacheShiftReal(ip_ex_gg_phi_gaga_ATLAS8_cache, NumPar, params, newResult);
1577  return newResult;
1578  }
1579 }
1580 
1581 double GMcache::ip_ex_pp_phi_gaga_ATLAS13(double mass){
1582  int NumPar = 1;
1583  double params[] = {mass};
1584 
1585  int i = CacheCheckReal(ip_ex_pp_phi_gaga_ATLAS13_cache, NumPar, params);
1586  if (i>=0) {
1587  return ( ip_ex_pp_phi_gaga_ATLAS13_cache[NumPar][i] );
1588  } else {
1589  double newResult = interpolate(ATLAS13_pp_phi_gaga,mass);
1590  CacheShiftReal(ip_ex_pp_phi_gaga_ATLAS13_cache, NumPar, params, newResult);
1591  return newResult;
1592  }
1593 }
1594 
1595 double GMcache::ip_ex_gg_phi_gaga_CMS13(double mass){
1596  int NumPar = 1;
1597  double params[] = {mass};
1598 
1599  int i = CacheCheckReal(ip_ex_gg_phi_gaga_CMS13_cache, NumPar, params);
1600  if (i>=0) {
1601  return ( ip_ex_gg_phi_gaga_CMS13_cache[NumPar][i] );
1602  } else {
1603  double newResult = interpolate(CMS13_gg_phi_gaga,mass);
1604  CacheShiftReal(ip_ex_gg_phi_gaga_CMS13_cache, NumPar, params, newResult);
1605  return newResult;
1606  }
1607 }
1608 
1609 double GMcache::ip_ex_pp_phi_Zga_llga_ATLAS8(double mass){
1610  int NumPar = 1;
1611  double params[] = {mass};
1612 
1613  int i = CacheCheckReal(ip_ex_pp_phi_Zga_llga_ATLAS8_cache, NumPar, params);
1614  if (i>=0) {
1615  return ( ip_ex_pp_phi_Zga_llga_ATLAS8_cache[NumPar][i] );
1616  } else {
1617  double newResult = interpolate(ATLAS8_pp_phi_Zga_llga,mass);
1618  CacheShiftReal(ip_ex_pp_phi_Zga_llga_ATLAS8_cache, NumPar, params, newResult);
1619  return newResult;
1620  }
1621 }
1622 
1623 double GMcache::ip_ex_pp_phi_Zga_llga_CMS8(double mass){
1624  int NumPar = 1;
1625  double params[] = {mass};
1626 
1627  int i = CacheCheckReal(ip_ex_pp_phi_Zga_llga_CMS8_cache, NumPar, params);
1628  if (i>=0) {
1629  return ( ip_ex_pp_phi_Zga_llga_CMS8_cache[NumPar][i] );
1630  } else {
1631  double newResult = interpolate(CMS8_pp_phi_Zga_llga,mass);
1632  CacheShiftReal(ip_ex_pp_phi_Zga_llga_CMS8_cache, NumPar, params, newResult);
1633  return newResult;
1634  }
1635 }
1636 
1637 double GMcache::ip_ex_gg_phi_Zga_llga_ATLAS13(double mass){
1638  int NumPar = 1;
1639  double params[] = {mass};
1640 
1641  int i = CacheCheckReal(ip_ex_gg_phi_Zga_llga_ATLAS13_cache, NumPar, params);
1642  if (i>=0) {
1643  return ( ip_ex_gg_phi_Zga_llga_ATLAS13_cache[NumPar][i] );
1644  } else {
1645  double newResult = interpolate(ATLAS13_gg_phi_Zga_llga,mass);
1646  CacheShiftReal(ip_ex_gg_phi_Zga_llga_ATLAS13_cache, NumPar, params, newResult);
1647  return newResult;
1648  }
1649 }
1650 
1651 double GMcache::ip_ex_gg_phi_Zga_qqga_ATLAS13(double mass){
1652  int NumPar = 1;
1653  double params[] = {mass};
1654 
1655  int i = CacheCheckReal(ip_ex_gg_phi_Zga_qqga_ATLAS13_cache, NumPar, params);
1656  if (i>=0) {
1657  return ( ip_ex_gg_phi_Zga_qqga_ATLAS13_cache[NumPar][i] );
1658  } else {
1659  double newResult = interpolate(ATLAS13_gg_phi_Zga_qqga,mass);
1660  CacheShiftReal(ip_ex_gg_phi_Zga_qqga_ATLAS13_cache, NumPar, params, newResult);
1661  return newResult;
1662  }
1663 }
1664 
1665 double GMcache::ip_ex_gg_phi_Zga_CMS13(double mass){
1666  int NumPar = 1;
1667  double params[] = {mass};
1668 
1669  int i = CacheCheckReal(ip_ex_gg_phi_Zga_CMS13_cache, NumPar, params);
1670  if (i>=0) {
1671  return ( ip_ex_gg_phi_Zga_CMS13_cache[NumPar][i] );
1672  } else {
1673  double newResult = interpolate(CMS13_gg_phi_Zga,mass);
1674  CacheShiftReal(ip_ex_gg_phi_Zga_CMS13_cache, NumPar, params, newResult);
1675  return newResult;
1676  }
1677 }
1678 
1679 double GMcache::ip_ex_gg_phi_ZZ_ATLAS8(double mass){
1680  int NumPar = 1;
1681  double params[] = {mass};
1682 
1683  int i = CacheCheckReal(ip_ex_gg_phi_ZZ_ATLAS8_cache, NumPar, params);
1684  if (i>=0) {
1685  return ( ip_ex_gg_phi_ZZ_ATLAS8_cache[NumPar][i] );
1686  } else {
1687  double newResult = interpolate(ATLAS8_gg_phi_ZZ,mass);
1688  CacheShiftReal(ip_ex_gg_phi_ZZ_ATLAS8_cache, NumPar, params, newResult);
1689  return newResult;
1690  }
1691 }
1692 
1693 double GMcache::ip_ex_VV_phi_ZZ_ATLAS8(double mass){
1694  int NumPar = 1;
1695  double params[] = {mass};
1696 
1697  int i = CacheCheckReal(ip_ex_VV_phi_ZZ_ATLAS8_cache, NumPar, params);
1698  if (i>=0) {
1699  return ( ip_ex_VV_phi_ZZ_ATLAS8_cache[NumPar][i] );
1700  } else {
1701  double newResult = interpolate(ATLAS8_VV_phi_ZZ,mass);
1702  CacheShiftReal(ip_ex_VV_phi_ZZ_ATLAS8_cache, NumPar, params, newResult);
1703  return newResult;
1704  }
1705 }
1706 
1707 double GMcache::ip_ex_gg_phi_ZZ_llllnunu_ATLAS13(double mass){
1708  int NumPar = 1;
1709  double params[] = {mass};
1710 
1711  int i = CacheCheckReal(ip_ex_gg_phi_ZZ_llllnunu_ATLAS13_cache, NumPar, params);
1712  if (i>=0) {
1713  return ( ip_ex_gg_phi_ZZ_llllnunu_ATLAS13_cache[NumPar][i] );
1714  } else {
1715  double newResult = interpolate(ATLAS13_gg_phi_ZZ_llllnunu,mass);
1716  CacheShiftReal(ip_ex_gg_phi_ZZ_llllnunu_ATLAS13_cache, NumPar, params, newResult);
1717  return newResult;
1718  }
1719 }
1720 
1721 double GMcache::ip_ex_VV_phi_ZZ_llllnunu_ATLAS13(double mass){
1722  int NumPar = 1;
1723  double params[] = {mass};
1724 
1725  int i = CacheCheckReal(ip_ex_VV_phi_ZZ_llllnunu_ATLAS13_cache, NumPar, params);
1726  if (i>=0) {
1727  return ( ip_ex_VV_phi_ZZ_llllnunu_ATLAS13_cache[NumPar][i] );
1728  } else {
1729  double newResult = interpolate(ATLAS13_VV_phi_ZZ_llllnunu,mass);
1730  CacheShiftReal(ip_ex_VV_phi_ZZ_llllnunu_ATLAS13_cache, NumPar, params, newResult);
1731  return newResult;
1732  }
1733 }
1734 
1735 double GMcache::ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13(double mass){
1736  int NumPar = 1;
1737  double params[] = {mass};
1738 
1739  int i = CacheCheckReal(ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13_cache, NumPar, params);
1740  if (i>=0) {
1741  return ( ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13_cache[NumPar][i] );
1742  } else {
1743  double newResult = interpolate(ATLAS13_gg_phi_ZZ_qqllnunu,mass);
1744  CacheShiftReal(ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13_cache, NumPar, params, newResult);
1745  return newResult;
1746  }
1747 }
1748 
1749 double GMcache::ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13(double mass){
1750  int NumPar = 1;
1751  double params[] = {mass};
1752 
1753  int i = CacheCheckReal(ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13_cache, NumPar, params);
1754  if (i>=0) {
1755  return ( ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13_cache[NumPar][i] );
1756  } else {
1757  double newResult = interpolate(ATLAS13_VV_phi_ZZ_qqllnunu,mass);
1758  CacheShiftReal(ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13_cache, NumPar, params, newResult);
1759  return newResult;
1760  }
1761 }
1762 
1763 double GMcache::ip_ex_pp_phi_ZZ_llqqnunull_CMS13(double mass){
1764  int NumPar = 1;
1765  double params[] = {mass};
1766 
1767  int i = CacheCheckReal(ip_ex_pp_phi_ZZ_llqqnunull_CMS13_cache, NumPar, params);
1768  if (i>=0) {
1769  return ( ip_ex_pp_phi_ZZ_llqqnunull_CMS13_cache[NumPar][i] );
1770  } else {
1771  double newResult = interpolate(CMS13_pp_phi_ZZ_llqqnunull,mass);
1772  CacheShiftReal(ip_ex_pp_phi_ZZ_llqqnunull_CMS13_cache, NumPar, params, newResult);
1773  return newResult;
1774  }
1775 }
1776 
1777 double GMcache::ip_ex_VV_phi_ZZ_llqqnunull_CMS13(double mass){
1778  int NumPar = 1;
1779  double params[] = {mass};
1780 
1781  int i = CacheCheckReal(ip_ex_VV_phi_ZZ_llqqnunull_CMS13_cache, NumPar, params);
1782  if (i>=0) {
1783  return ( ip_ex_VV_phi_ZZ_llqqnunull_CMS13_cache[NumPar][i] );
1784  } else {
1785  double newResult = interpolate(CMS13_VV_phi_ZZ_llqqnunull,mass);
1786  CacheShiftReal(ip_ex_VV_phi_ZZ_llqqnunull_CMS13_cache, NumPar, params, newResult);
1787  return newResult;
1788  }
1789 }
1790 
1791 double GMcache::ip_ex_pp_phi_ZZ_qqnunu_CMS13(double mass){
1792  int NumPar = 1;
1793  double params[] = {mass};
1794 
1795  int i = CacheCheckReal(ip_ex_pp_phi_ZZ_qqnunu_CMS13_cache, NumPar, params);
1796  if (i>=0) {
1797  return ( ip_ex_pp_phi_ZZ_qqnunu_CMS13_cache[NumPar][i] );
1798  } else {
1799  double newResult = interpolate(CMS13_pp_phi_ZZ_qqnunu,mass);
1800  CacheShiftReal(ip_ex_pp_phi_ZZ_qqnunu_CMS13_cache, NumPar, params, newResult);
1801  return newResult;
1802  }
1803 }
1804 
1805 double GMcache::ip_ex_gg_phi_WW_ATLAS8(double mass){
1806  int NumPar = 1;
1807  double params[] = {mass};
1808 
1809  int i = CacheCheckReal(ip_ex_gg_phi_WW_ATLAS8_cache, NumPar, params);
1810  if (i>=0) {
1811  return ( ip_ex_gg_phi_WW_ATLAS8_cache[NumPar][i] );
1812  } else {
1813  double newResult = interpolate(ATLAS8_gg_phi_WW,mass);
1814  CacheShiftReal(ip_ex_gg_phi_WW_ATLAS8_cache, NumPar, params, newResult);
1815  return newResult;
1816  }
1817 }
1818 
1819 double GMcache::ip_ex_VV_phi_WW_ATLAS8(double mass){
1820  int NumPar = 1;
1821  double params[] = {mass};
1822 
1823  int i = CacheCheckReal(ip_ex_VV_phi_WW_ATLAS8_cache, NumPar, params);
1824  if (i>=0) {
1825  return ( ip_ex_VV_phi_WW_ATLAS8_cache[NumPar][i] );
1826  } else {
1827  double newResult = interpolate(ATLAS8_VV_phi_WW,mass);
1828  CacheShiftReal(ip_ex_VV_phi_WW_ATLAS8_cache, NumPar, params, newResult);
1829  return newResult;
1830  }
1831 }
1832 
1833 double GMcache::ip_ex_gg_phi_WW_enumunu_ATLAS13(double mass){
1834  int NumPar = 1;
1835  double params[] = {mass};
1836 
1837  int i = CacheCheckReal(ip_ex_gg_phi_WW_enumunu_ATLAS13_cache, NumPar, params);
1838  if (i>=0) {
1839  return ( ip_ex_gg_phi_WW_enumunu_ATLAS13_cache[NumPar][i] );
1840  } else {
1841  double newResult = interpolate(ATLAS13_gg_phi_WW_enumunu,mass);
1842  CacheShiftReal(ip_ex_gg_phi_WW_enumunu_ATLAS13_cache, NumPar, params, newResult);
1843  return newResult;
1844  }
1845 }
1846 
1847 double GMcache::ip_ex_VV_phi_WW_enumunu_ATLAS13(double mass){
1848  int NumPar = 1;
1849  double params[] = {mass};
1850 
1851  int i = CacheCheckReal(ip_ex_VV_phi_WW_enumunu_ATLAS13_cache, NumPar, params);
1852  if (i>=0) {
1853  return ( ip_ex_VV_phi_WW_enumunu_ATLAS13_cache[NumPar][i] );
1854  } else {
1855  double newResult = interpolate(ATLAS13_VV_phi_WW_enumunu,mass);
1856  CacheShiftReal(ip_ex_VV_phi_WW_enumunu_ATLAS13_cache, NumPar, params, newResult);
1857  return newResult;
1858  }
1859 }
1860 
1861 double GMcache::ip_ex_gg_phi_WW_lnuqq_ATLAS13(double mass){
1862  int NumPar = 1;
1863  double params[] = {mass};
1864 
1865  int i = CacheCheckReal(ip_ex_gg_phi_WW_lnuqq_ATLAS13_cache, NumPar, params);
1866  if (i>=0) {
1867  return ( ip_ex_gg_phi_WW_lnuqq_ATLAS13_cache[NumPar][i] );
1868  } else {
1869  double newResult = interpolate(ATLAS13_gg_phi_WW_lnuqq,mass);
1870  CacheShiftReal(ip_ex_gg_phi_WW_lnuqq_ATLAS13_cache, NumPar, params, newResult);
1871  return newResult;
1872  }
1873 }
1874 
1875 double GMcache::ip_ex_VV_phi_WW_lnuqq_ATLAS13(double mass){
1876  int NumPar = 1;
1877  double params[] = {mass};
1878 
1879  int i = CacheCheckReal(ip_ex_VV_phi_WW_lnuqq_ATLAS13_cache, NumPar, params);
1880  if (i>=0) {
1881  return ( ip_ex_VV_phi_WW_lnuqq_ATLAS13_cache[NumPar][i] );
1882  } else {
1883  double newResult = interpolate(ATLAS13_VV_phi_WW_lnuqq,mass);
1884  CacheShiftReal(ip_ex_VV_phi_WW_lnuqq_ATLAS13_cache, NumPar, params, newResult);
1885  return newResult;
1886  }
1887 }
1888 
1889 double GMcache::ip_ex_ggVV_phi_WW_lnulnu_CMS13(double mass){
1890  int NumPar = 1;
1891  double params[] = {mass};
1892 
1893  int i = CacheCheckReal(ip_ex_ggVV_phi_WW_lnulnu_CMS13_cache, NumPar, params);
1894  if (i>=0) {
1895  return ( ip_ex_ggVV_phi_WW_lnulnu_CMS13_cache[NumPar][i] );
1896  } else {
1897  double newResult = interpolate(CMS13_ggVV_phi_WW_lnulnu,mass);
1898  CacheShiftReal(ip_ex_ggVV_phi_WW_lnulnu_CMS13_cache, NumPar, params, newResult);
1899  return newResult;
1900  }
1901 }
1902 
1903 double GMcache::ip_ex_pp_phi_WW_lnuqq_CMS13(double mass){
1904  int NumPar = 1;
1905  double params[] = {mass};
1906 
1907  int i = CacheCheckReal(ip_ex_pp_phi_WW_lnuqq_CMS13_cache, NumPar, params);
1908  if (i>=0) {
1909  return ( ip_ex_pp_phi_WW_lnuqq_CMS13_cache[NumPar][i] );
1910  } else {
1911  double newResult = interpolate(CMS13_pp_phi_WW_lnuqq,mass);
1912  CacheShiftReal(ip_ex_pp_phi_WW_lnuqq_CMS13_cache, NumPar, params, newResult);
1913  return newResult;
1914  }
1915 }
1916 
1917 double GMcache::ip_ex_mu_pp_phi_VV_CMS8(double mass){
1918  int NumPar = 1;
1919  double params[] = {mass};
1920 
1921  int i = CacheCheckReal(ip_ex_mu_pp_phi_VV_CMS8_cache, NumPar, params);
1922  if (i>=0) {
1923  return ( ip_ex_mu_pp_phi_VV_CMS8_cache[NumPar][i] );
1924  } else {
1925  double newResult = interpolate(CMS8_mu_pp_phi_VV,mass);
1926  CacheShiftReal(ip_ex_mu_pp_phi_VV_CMS8_cache, NumPar, params, newResult);
1927  return newResult;
1928  }
1929 }
1930 
1931 double GMcache::ip_ex_pp_phi_VV_qqqq_ATLAS13(double mass){
1932  int NumPar = 1;
1933  double params[] = {mass};
1934 
1935  int i = CacheCheckReal(ip_ex_pp_phi_VV_qqqq_ATLAS13_cache, NumPar, params);
1936  if (i>=0) {
1937  return ( ip_ex_pp_phi_VV_qqqq_ATLAS13_cache[NumPar][i] );
1938  } else {
1939  double newResult = interpolate(ATLAS13_pp_phi_VV_qqqq,mass);
1940  CacheShiftReal(ip_ex_pp_phi_VV_qqqq_ATLAS13_cache, NumPar, params, newResult);
1941  return newResult;
1942  }
1943 }
1944 
1945 double GMcache::ip_ex_gg_phi_hh_ATLAS8(double mass){
1946  int NumPar = 1;
1947  double params[] = {mass};
1948 
1949  int i = CacheCheckReal(ip_ex_gg_phi_hh_ATLAS8_cache, NumPar, params);
1950  if (i>=0) {
1951  return ( ip_ex_gg_phi_hh_ATLAS8_cache[NumPar][i] );
1952  } else {
1953  double newResult = interpolate(ATLAS8_gg_phi_hh,mass);
1954  CacheShiftReal(ip_ex_gg_phi_hh_ATLAS8_cache, NumPar, params, newResult);
1955  return newResult;
1956  }
1957 }
1958 
1959 double GMcache::ip_ex_pp_phi_hh_bbbb_CMS8(double mass){
1960  int NumPar = 1;
1961  double params[] = {mass};
1962 
1963  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbbb_CMS8_cache, NumPar, params);
1964  if (i>=0) {
1965  return ( ip_ex_pp_phi_hh_bbbb_CMS8_cache[NumPar][i] );
1966  } else {
1967  double newResult = interpolate(CMS8_pp_phi_hh_bbbb,mass);
1968  CacheShiftReal(ip_ex_pp_phi_hh_bbbb_CMS8_cache, NumPar, params, newResult);
1969  return newResult;
1970  }
1971 }
1972 
1973 double GMcache::ip_ex_pp_phi_hh_gagabb_CMS8(double mass){
1974  int NumPar = 1;
1975  double params[] = {mass};
1976 
1977  int i = CacheCheckReal(ip_ex_pp_phi_hh_gagabb_CMS8_cache, NumPar, params);
1978  if (i>=0) {
1979  return ( ip_ex_pp_phi_hh_gagabb_CMS8_cache[NumPar][i] );
1980  } else {
1981  double newResult = interpolate(CMS8_pp_phi_hh_gagabb,mass);
1982  CacheShiftReal(ip_ex_pp_phi_hh_gagabb_CMS8_cache, NumPar, params, newResult);
1983  return newResult;
1984  }
1985 }
1986 
1987 double GMcache::ip_ex_gg_phi_hh_bbtautau_CMS8(double mass){
1988  int NumPar = 1;
1989  double params[] = {mass};
1990 
1991  int i = CacheCheckReal(ip_ex_gg_phi_hh_bbtautau_CMS8_cache, NumPar, params);
1992  if (i>=0) {
1993  return ( ip_ex_gg_phi_hh_bbtautau_CMS8_cache[NumPar][i] );
1994  } else {
1995  double newResult = interpolate(CMS8_gg_phi_hh_bbtautau,mass);
1996  CacheShiftReal(ip_ex_gg_phi_hh_bbtautau_CMS8_cache, NumPar, params, newResult);
1997  return newResult;
1998  }
1999 }
2000 
2001 double GMcache::ip_ex_pp_phi_hh_bbtautau_CMS8(double mass){
2002  int NumPar = 1;
2003  double params[] = {mass};
2004 
2005  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbtautau_CMS8_cache, NumPar, params);
2006  if (i>=0) {
2007  return ( ip_ex_pp_phi_hh_bbtautau_CMS8_cache[NumPar][i] );
2008  } else {
2009  double newResult = interpolate(CMS8_pp_phi_hh_bbtautau,mass);
2010  CacheShiftReal(ip_ex_pp_phi_hh_bbtautau_CMS8_cache, NumPar, params, newResult);
2011  return newResult;
2012  }
2013 }
2014 
2015 double GMcache::ip_ex_pp_phi_hh_bbbb_ATLAS13(double mass){
2016  int NumPar = 1;
2017  double params[] = {mass};
2018 
2019  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbbb_ATLAS13_cache, NumPar, params);
2020  if (i>=0) {
2021  return ( ip_ex_pp_phi_hh_bbbb_ATLAS13_cache[NumPar][i] );
2022  } else {
2023  double newResult = interpolate(ATLAS13_pp_phi_hh_bbbb,mass);
2024  CacheShiftReal(ip_ex_pp_phi_hh_bbbb_ATLAS13_cache, NumPar, params, newResult);
2025  return newResult;
2026  }
2027 }
2028 
2029 double GMcache::ip_ex_pp_phi_hh_bbbb_1_CMS13(double mass){
2030  int NumPar = 1;
2031  double params[] = {mass};
2032 
2033  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbbb_1_CMS13_cache, NumPar, params);
2034  if (i>=0) {
2035  return ( ip_ex_pp_phi_hh_bbbb_1_CMS13_cache[NumPar][i] );
2036  } else {
2037  double newResult = interpolate(CMS13_pp_phi_hh_bbbb_1,mass);
2038  CacheShiftReal(ip_ex_pp_phi_hh_bbbb_1_CMS13_cache, NumPar, params, newResult);
2039  return newResult;
2040  }
2041 }
2042 
2043 double GMcache::ip_ex_pp_phi_hh_bbbb_2_CMS13(double mass){
2044  int NumPar = 1;
2045  double params[] = {mass};
2046 
2047  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbbb_2_CMS13_cache, NumPar, params);
2048  if (i>=0) {
2049  return ( ip_ex_pp_phi_hh_bbbb_2_CMS13_cache[NumPar][i] );
2050  } else {
2051  double newResult = interpolate(CMS13_pp_phi_hh_bbbb_2,mass);
2052  CacheShiftReal(ip_ex_pp_phi_hh_bbbb_2_CMS13_cache, NumPar, params, newResult);
2053  return newResult;
2054  }
2055 }
2056 
2057 double GMcache::ip_ex_gg_phi_hh_bbbb_CMS13(double mass){
2058  int NumPar = 1;
2059  double params[] = {mass};
2060 
2061  int i = CacheCheckReal(ip_ex_gg_phi_hh_bbbb_CMS13_cache, NumPar, params);
2062  if (i>=0) {
2063  return ( ip_ex_gg_phi_hh_bbbb_CMS13_cache[NumPar][i] );
2064  } else {
2065  double newResult = interpolate(CMS13_gg_phi_hh_bbbb,mass);
2066  CacheShiftReal(ip_ex_gg_phi_hh_bbbb_CMS13_cache, NumPar, params, newResult);
2067  return newResult;
2068  }
2069 }
2070 
2071 double GMcache::ip_ex_pp_phi_hh_gagabb_ATLAS13(double mass){
2072  int NumPar = 1;
2073  double params[] = {mass};
2074 
2075  int i = CacheCheckReal(ip_ex_pp_phi_hh_gagabb_ATLAS13_cache, NumPar, params);
2076  if (i>=0) {
2077  return ( ip_ex_pp_phi_hh_gagabb_ATLAS13_cache[NumPar][i] );
2078  } else {
2079  double newResult = interpolate(ATLAS13_pp_phi_hh_gagabb,mass);
2080  CacheShiftReal(ip_ex_pp_phi_hh_gagabb_ATLAS13_cache, NumPar, params, newResult);
2081  return newResult;
2082  }
2083 }
2084 
2085 double GMcache::ip_ex_pp_phi_hh_gagabb_CMS13(double mass){
2086  int NumPar = 1;
2087  double params[] = {mass};
2088 
2089  int i = CacheCheckReal(ip_ex_pp_phi_hh_gagabb_CMS13_cache, NumPar, params);
2090  if (i>=0) {
2091  return ( ip_ex_pp_phi_hh_gagabb_CMS13_cache[NumPar][i] );
2092  } else {
2093  double newResult = interpolate(CMS13_pp_phi_hh_gagabb,mass);
2094  CacheShiftReal(ip_ex_pp_phi_hh_gagabb_CMS13_cache, NumPar, params, newResult);
2095  return newResult;
2096  }
2097 }
2098 
2099 double GMcache::ip_ex_pp_phi_hh_bbtautau_ATLAS13(double mass){
2100  int NumPar = 1;
2101  double params[] = {mass};
2102 
2103  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbtautau_ATLAS13_cache, NumPar, params);
2104  if (i>=0) {
2105  return ( ip_ex_pp_phi_hh_bbtautau_ATLAS13_cache[NumPar][i] );
2106  } else {
2107  double newResult = interpolate(ATLAS13_pp_phi_hh_bbtautau,mass);
2108  CacheShiftReal(ip_ex_pp_phi_hh_bbtautau_ATLAS13_cache, NumPar, params, newResult);
2109  return newResult;
2110  }
2111 }
2112 
2113 double GMcache::ip_ex_pp_phi_hh_bbtautau_1_CMS13(double mass){
2114  int NumPar = 1;
2115  double params[] = {mass};
2116 
2117  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbtautau_1_CMS13_cache, NumPar, params);
2118  if (i>=0) {
2119  return ( ip_ex_pp_phi_hh_bbtautau_1_CMS13_cache[NumPar][i] );
2120  } else {
2121  double newResult = interpolate(CMS13_pp_phi_hh_bbtautau_1,mass);
2122  CacheShiftReal(ip_ex_pp_phi_hh_bbtautau_1_CMS13_cache, NumPar, params, newResult);
2123  return newResult;
2124  }
2125 }
2126 
2127 double GMcache::ip_ex_pp_phi_hh_bbtautau_2_CMS13(double mass){
2128  int NumPar = 1;
2129  double params[] = {mass};
2130 
2131  int i = CacheCheckReal(ip_ex_pp_phi_hh_bbtautau_2_CMS13_cache, NumPar, params);
2132  if (i>=0) {
2133  return ( ip_ex_pp_phi_hh_bbtautau_2_CMS13_cache[NumPar][i] );
2134  } else {
2135  double newResult = interpolate(CMS13_pp_phi_hh_bbtautau_2,mass);
2136  CacheShiftReal(ip_ex_pp_phi_hh_bbtautau_2_CMS13_cache, NumPar, params, newResult);
2137  return newResult;
2138  }
2139 }
2140 
2141 double GMcache::ip_ex_pp_phi_hh_bblnulnu_CMS13(double mass){
2142  int NumPar = 1;
2143  double params[] = {mass};
2144 
2145  int i = CacheCheckReal(ip_ex_pp_phi_hh_bblnulnu_CMS13_cache, NumPar, params);
2146  if (i>=0) {
2147  return ( ip_ex_pp_phi_hh_bblnulnu_CMS13_cache[NumPar][i] );
2148  } else {
2149  double newResult = interpolate(CMS13_pp_phi_hh_bblnulnu,mass);
2150  CacheShiftReal(ip_ex_pp_phi_hh_bblnulnu_CMS13_cache, NumPar, params, newResult);
2151  return newResult;
2152  }
2153 }
2154 
2155 double GMcache::ip_ex_gg_phi_hh_gagaWW_ATLAS13(double mass){
2156  int NumPar = 1;
2157  double params[] = {mass};
2158 
2159  int i = CacheCheckReal(ip_ex_gg_phi_hh_gagaWW_ATLAS13_cache, NumPar, params);
2160  if (i>=0) {
2161  return ( ip_ex_gg_phi_hh_gagaWW_ATLAS13_cache[NumPar][i] );
2162  } else {
2163  double newResult = interpolate(ATLAS13_gg_phi_hh_gagaWW,mass);
2164  CacheShiftReal(ip_ex_gg_phi_hh_gagaWW_ATLAS13_cache, NumPar, params, newResult);
2165  return newResult;
2166  }
2167 }
2168 
2169 double GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS8(double mass){
2170  int NumPar = 1;
2171  double params[] = {mass};
2172 
2173  int i = CacheCheckReal(ip_ex_gg_A_hZ_bbZ_ATLAS8_cache, NumPar, params);
2174  if (i>=0) {
2175  return ( ip_ex_gg_A_hZ_bbZ_ATLAS8_cache[NumPar][i] );
2176  } else {
2177  double newResult = interpolate(ATLAS8_gg_A_hZ_bbZ,mass);
2178  CacheShiftReal(ip_ex_gg_A_hZ_bbZ_ATLAS8_cache, NumPar, params, newResult);
2179  return newResult;
2180  }
2181 }
2182 
2183 double GMcache::ip_ex_gg_A_hZ_bbll_CMS8(double mass){
2184  int NumPar = 1;
2185  double params[] = {mass};
2186 
2187  int i = CacheCheckReal(ip_ex_gg_A_hZ_bbll_CMS8_cache, NumPar, params);
2188  if (i>=0) {
2189  return ( ip_ex_gg_A_hZ_bbll_CMS8_cache[NumPar][i] );
2190  } else {
2191  double newResult = interpolate(CMS8_gg_A_hZ_bbll,mass);
2192  CacheShiftReal(ip_ex_gg_A_hZ_bbll_CMS8_cache, NumPar, params, newResult);
2193  return newResult;
2194  }
2195 }
2196 
2197 double GMcache::ip_ex_gg_A_hZ_tautauZ_ATLAS8(double mass){
2198  int NumPar = 1;
2199  double params[] = {mass};
2200 
2201  int i = CacheCheckReal(ip_ex_gg_A_hZ_tautauZ_ATLAS8_cache, NumPar, params);
2202  if (i>=0) {
2203  return ( ip_ex_gg_A_hZ_tautauZ_ATLAS8_cache[NumPar][i] );
2204  } else {
2205  double newResult = interpolate(ATLAS8_gg_A_hZ_tautauZ,mass);
2206  CacheShiftReal(ip_ex_gg_A_hZ_tautauZ_ATLAS8_cache, NumPar, params, newResult);
2207  return newResult;
2208  }
2209 }
2210 
2211 double GMcache::ip_ex_gg_A_hZ_tautaull_CMS8(double mass){
2212  int NumPar = 1;
2213  double params[] = {mass};
2214 
2215  int i = CacheCheckReal(ip_ex_gg_A_hZ_tautaull_CMS8_cache, NumPar, params);
2216  if (i>=0) {
2217  return ( ip_ex_gg_A_hZ_tautaull_CMS8_cache[NumPar][i] );
2218  } else {
2219  double newResult = interpolate(CMS8_gg_A_hZ_tautaull,mass);
2220  CacheShiftReal(ip_ex_gg_A_hZ_tautaull_CMS8_cache, NumPar, params, newResult);
2221  return newResult;
2222  }
2223 }
2224 
2225 double GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS13(double mass){
2226  int NumPar = 1;
2227  double params[] = {mass};
2228 
2229  int i = CacheCheckReal(ip_ex_gg_A_hZ_bbZ_ATLAS13_cache, NumPar, params);
2230  if (i>=0) {
2231  return ( ip_ex_gg_A_hZ_bbZ_ATLAS13_cache[NumPar][i] );
2232  } else {
2233  double newResult = interpolate(ATLAS13_gg_A_Zh_Zbb,mass);
2234  CacheShiftReal(ip_ex_gg_A_hZ_bbZ_ATLAS13_cache, NumPar, params, newResult);
2235  return newResult;
2236  }
2237 }
2238 
2239 double GMcache::ip_ex_bb_A_hZ_bbZ_ATLAS13(double mass){
2240  int NumPar = 1;
2241  double params[] = {mass};
2242 
2243  int i = CacheCheckReal(ip_ex_bb_A_hZ_bbZ_ATLAS13_cache, NumPar, params);
2244  if (i>=0) {
2245  return ( ip_ex_bb_A_hZ_bbZ_ATLAS13_cache[NumPar][i] );
2246  } else {
2247  double newResult = interpolate(ATLAS13_bb_A_Zh_Zbb,mass);
2248  CacheShiftReal(ip_ex_bb_A_hZ_bbZ_ATLAS13_cache, NumPar, params, newResult);
2249  return newResult;
2250  }
2251 }
2252 
2253 double GMcache::ip_ex_gg_A_hZ_bbZ_1_CMS13(double mass){
2254  int NumPar = 1;
2255  double params[] = {mass};
2256 
2257  int i = CacheCheckReal(ip_ex_gg_A_hZ_bbZ_1_CMS13_cache, NumPar, params);
2258  if (i>=0) {
2259  return ( ip_ex_gg_A_hZ_bbZ_1_CMS13_cache[NumPar][i] );
2260  } else {
2261  double newResult = interpolate(CMS13_gg_A_Zh_Zbb_1,mass);
2262  CacheShiftReal(ip_ex_gg_A_hZ_bbZ_1_CMS13_cache, NumPar, params, newResult);
2263  return newResult;
2264  }
2265 }
2266 
2267 double GMcache::ip_ex_bb_A_hZ_bbZ_1_CMS13(double mass){
2268  int NumPar = 1;
2269  double params[] = {mass};
2270 
2271  int i = CacheCheckReal(ip_ex_bb_A_hZ_bbZ_1_CMS13_cache, NumPar, params);
2272  if (i>=0) {
2273  return ( ip_ex_bb_A_hZ_bbZ_1_CMS13_cache[NumPar][i] );
2274  } else {
2275  double newResult = interpolate(CMS13_bb_A_Zh_Zbb_1,mass);
2276  CacheShiftReal(ip_ex_bb_A_hZ_bbZ_1_CMS13_cache, NumPar, params, newResult);
2277  return newResult;
2278  }
2279 }
2280 
2281 double GMcache::ip_ex_gg_A_hZ_bbZ_2_CMS13(double mass){
2282  int NumPar = 1;
2283  double params[] = {mass};
2284 
2285  int i = CacheCheckReal(ip_ex_gg_A_hZ_bbZ_2_CMS13_cache, NumPar, params);
2286  if (i>=0) {
2287  return ( ip_ex_gg_A_hZ_bbZ_2_CMS13_cache[NumPar][i] );
2288  } else {
2289  double newResult = interpolate(CMS13_gg_A_Zh_Zbb_2,mass);
2290  CacheShiftReal(ip_ex_gg_A_hZ_bbZ_2_CMS13_cache, NumPar, params, newResult);
2291  return newResult;
2292  }
2293 }
2294 
2295 double GMcache::ip_ex_bb_A_hZ_bbZ_2_CMS13(double mass){
2296  int NumPar = 1;
2297  double params[] = {mass};
2298 
2299  int i = CacheCheckReal(ip_ex_bb_A_hZ_bbZ_2_CMS13_cache, NumPar, params);
2300  if (i>=0) {
2301  return ( ip_ex_bb_A_hZ_bbZ_2_CMS13_cache[NumPar][i] );
2302  } else {
2303  double newResult = interpolate(CMS13_bb_A_Zh_Zbb_2,mass);
2304  CacheShiftReal(ip_ex_bb_A_hZ_bbZ_2_CMS13_cache, NumPar, params, newResult);
2305  return newResult;
2306  }
2307 }
2308 
2309 double GMcache::ip_ex_pp_A_phiZ_bbll_CMS8(double mA, double mH){
2310  int NumPar = 2;
2311  double params[] = {mA,mH};
2312 
2313  int i = CacheCheckReal(ip_ex_pp_A_phiZ_bbll_CMS8_cache, NumPar, params);
2314  if (i>=0) {
2315  return ( ip_ex_pp_A_phiZ_bbll_CMS8_cache[NumPar][i] );
2316  } else {
2317  double newResult = interpolate2D(CMS8_pp_A_phiZ_bbll,mA,mH);
2318  CacheShiftReal(ip_ex_pp_A_phiZ_bbll_CMS8_cache, NumPar, params, newResult);
2319  return newResult;
2320  }
2321 }
2322 
2323 double GMcache::ip_ex_pp_phi_AZ_bbll_CMS8(double mA, double mH){
2324  int NumPar = 2;
2325  double params[] = {mA,mH};
2326 
2327  int i = CacheCheckReal(ip_ex_pp_phi_AZ_bbll_CMS8_cache, NumPar, params);
2328  if (i>=0) {
2329  return ( ip_ex_pp_phi_AZ_bbll_CMS8_cache[NumPar][i] );
2330  } else {
2331  double newResult = interpolate2D(CMS8_pp_phi_AZ_bbll,mA,mH);
2332  CacheShiftReal(ip_ex_pp_phi_AZ_bbll_CMS8_cache, NumPar, params, newResult);
2333  return newResult;
2334  }
2335 }
2336 
2337 double GMcache::ip_ex_gg_A_phiZ_bbll_ATLAS13(double mA, double mH){
2338  int NumPar = 2;
2339  double params[] = {mA,mH};
2340 
2341  int i = CacheCheckReal(ip_ex_gg_A_phiZ_bbll_ATLAS13_cache, NumPar, params);
2342  if (i>=0) {
2343  return ( ip_ex_gg_A_phiZ_bbll_ATLAS13_cache[NumPar][i] );
2344  } else {
2345  double newResult = interpolate2D(ATLAS13_gg_A_phiZ_bbll,mA,mH);
2346  CacheShiftReal(ip_ex_gg_A_phiZ_bbll_ATLAS13_cache, NumPar, params, newResult);
2347  return newResult;
2348  }
2349 }
2350 
2351 double GMcache::ip_ex_bb_A_phiZ_bbll_ATLAS13(double mA, double mH){
2352  int NumPar = 2;
2353  double params[] = {mA,mH};
2354 
2355  int i = CacheCheckReal(ip_ex_bb_A_phiZ_bbll_ATLAS13_cache, NumPar, params);
2356  if (i>=0) {
2357  return ( ip_ex_bb_A_phiZ_bbll_ATLAS13_cache[NumPar][i] );
2358  } else {
2359  double newResult = interpolate2D(ATLAS13_bb_A_phiZ_bbll,mA,mH);
2360  CacheShiftReal(ip_ex_bb_A_phiZ_bbll_ATLAS13_cache, NumPar, params, newResult);
2361  return newResult;
2362  }
2363 }
2364 
2365 double GMcache::ip_ex_pp_Hpm_taunu_ATLAS8(double mHp){
2366  int NumPar = 1;
2367  double params[] = {mHp};
2368 
2369  int i = CacheCheckReal(ip_ex_pp_Hpm_taunu_ATLAS8_cache, NumPar, params);
2370  if (i>=0) {
2371  return ( ip_ex_pp_Hpm_taunu_ATLAS8_cache[NumPar][i] );
2372  } else {
2373  double newResult = interpolate(ATLAS8_pp_Hpm_taunu,mHp);
2374  CacheShiftReal(ip_ex_pp_Hpm_taunu_ATLAS8_cache, NumPar, params, newResult);
2375  return newResult;
2376  }
2377 }
2378 
2379 double GMcache::ip_ex_pp_Hp_taunu_CMS8(double mHp){
2380  int NumPar = 1;
2381  double params[] = {mHp};
2382 
2383  int i = CacheCheckReal(ip_ex_pp_Hp_taunu_CMS8_cache, NumPar, params);
2384  if (i>=0) {
2385  return ( ip_ex_pp_Hp_taunu_CMS8_cache[NumPar][i] );
2386  } else {
2387  double newResult = interpolate(CMS8_pp_Hp_taunu,mHp);
2388  CacheShiftReal(ip_ex_pp_Hp_taunu_CMS8_cache, NumPar, params, newResult);
2389  return newResult;
2390  }
2391 }
2392 
2393 double GMcache::ip_ex_pp_Hpm_taunu_ATLAS13(double mHp){
2394  int NumPar = 1;
2395  double params[] = {mHp};
2396 
2397  int i = CacheCheckReal(ip_ex_pp_Hpm_taunu_ATLAS13_cache, NumPar, params);
2398  if (i>=0) {
2399  return ( ip_ex_pp_Hpm_taunu_ATLAS13_cache[NumPar][i] );
2400  } else {
2401  double newResult = interpolate(ATLAS13_pp_Hpm_taunu,mHp);
2402  CacheShiftReal(ip_ex_pp_Hpm_taunu_ATLAS13_cache, NumPar, params, newResult);
2403  return newResult;
2404  }
2405 }
2406 
2407 double GMcache::ip_ex_pp_Hpm_taunu_CMS13(double mHp){
2408  int NumPar = 1;
2409  double params[] = {mHp};
2410 
2411  int i = CacheCheckReal(ip_ex_pp_Hpm_taunu_CMS13_cache, NumPar, params);
2412  if (i>=0) {
2413  return ( ip_ex_pp_Hpm_taunu_CMS13_cache[NumPar][i] );
2414  } else {
2415  double newResult = interpolate(CMS13_pp_Hpm_taunu,mHp);
2416  CacheShiftReal(ip_ex_pp_Hpm_taunu_CMS13_cache, NumPar, params, newResult);
2417  return newResult;
2418  }
2419 }
2420 
2421 double GMcache::ip_ex_pp_Hpm_tb_ATLAS8(double mHp){
2422  int NumPar = 1;
2423  double params[] = {mHp};
2424 
2425  int i = CacheCheckReal(ip_ex_pp_Hpm_tb_ATLAS8_cache, NumPar, params);
2426  if (i>=0) {
2427  return ( ip_ex_pp_Hpm_tb_ATLAS8_cache[NumPar][i] );
2428  } else {
2429  double newResult = interpolate(ATLAS8_pp_Hpm_tb,mHp);
2430  CacheShiftReal(ip_ex_pp_Hpm_tb_ATLAS8_cache, NumPar, params, newResult);
2431  return newResult;
2432  }
2433 }
2434 
2435 double GMcache::ip_ex_pp_Hp_tb_CMS8(double mHp){
2436  int NumPar = 1;
2437  double params[] = {mHp};
2438 
2439  int i = CacheCheckReal(ip_ex_pp_Hp_tb_CMS8_cache, NumPar, params);
2440  if (i>=0) {
2441  return ( ip_ex_pp_Hp_tb_CMS8_cache[NumPar][i] );
2442  } else {
2443  double newResult = interpolate(CMS8_pp_Hp_tb,mHp);
2444  CacheShiftReal(ip_ex_pp_Hp_tb_CMS8_cache, NumPar, params, newResult);
2445  return newResult;
2446  }
2447 }
2448 
2449 double GMcache::ip_ex_pp_Hpm_tb_ATLAS13(double mHp){
2450  int NumPar = 1;
2451  double params[] = {mHp};
2452 
2453  int i = CacheCheckReal(ip_ex_pp_Hpm_tb_ATLAS13_cache, NumPar, params);
2454  if (i>=0) {
2455  return ( ip_ex_pp_Hpm_tb_ATLAS13_cache[NumPar][i] );
2456  } else {
2457  double newResult = interpolate(ATLAS13_pp_Hpm_tb,mHp);
2458  CacheShiftReal(ip_ex_pp_Hpm_tb_ATLAS13_cache, NumPar, params, newResult);
2459  return newResult;
2460  }
2461 }
2462 
2463 double GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13(double mH5){
2464  int NumPar = 1;
2465  double params[] = {mH5};
2466 
2467  int i = CacheCheckReal(ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_cache, NumPar, params);
2468  if (i>=0) {
2469  return ( ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_cache[NumPar][i] );
2470  } else {
2471  double newResult = interpolate(ATLAS13_WZ_H5pm_WZ_lnull,mH5);
2472  CacheShiftReal(ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_cache, NumPar, params, newResult);
2473  return newResult;
2474  }
2475 }
2476 
2477 double GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e(double mH5){
2478  int NumPar = 1;
2479  double params[] = {mH5};
2480 
2481  int i = CacheCheckReal(ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e_cache, NumPar, params);
2482  if (i>=0) {
2483  return ( ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e_cache[NumPar][i] );
2484  } else {
2485  double newResult = interpolate(ATLAS13_WZ_H5pm_WZ_lnull_e,mH5);
2486  CacheShiftReal(ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e_cache, NumPar, params, newResult);
2487  return newResult;
2488  }
2489 }
2490 
2491 double GMcache::ip_ex_WZ_H5pm_WZ_qqll_ATLAS8(double mH5){
2492  int NumPar = 1;
2493  double params[] = {mH5};
2494 
2495  int i = CacheCheckReal(ip_ex_WZ_H5pm_WZ_qqll_ATLAS8_cache, NumPar, params);
2496  if (i>=0) {
2497  return ( ip_ex_WZ_H5pm_WZ_qqll_ATLAS8_cache[NumPar][i] );
2498  } else {
2499  double newResult = interpolate(ATLAS8_WZ_H5pm_WZ_qqll,mH5);
2500  CacheShiftReal(ip_ex_WZ_H5pm_WZ_qqll_ATLAS8_cache, NumPar, params, newResult);
2501  return newResult;
2502  }
2503 }
2504 
2505 double GMcache::ip_ex_WZ_H5pm_WZ_lnull_1_CMS13(double mH5){
2506  int NumPar = 1;
2507  double params[] = {mH5};
2508 
2509  int i = CacheCheckReal(ip_ex_WZ_H5pm_WZ_lnull_1_CMS13_cache, NumPar, params);
2510  if (i>=0) {
2511  return ( ip_ex_WZ_H5pm_WZ_lnull_1_CMS13_cache[NumPar][i] );
2512  } else {
2513  double newResult = interpolate(CMS13_WZ_H5pm_WZ_lnull_1,mH5);
2514  CacheShiftReal(ip_ex_WZ_H5pm_WZ_lnull_1_CMS13_cache, NumPar, params, newResult);
2515  return newResult;
2516  }
2517 }
2518 
2519 double GMcache::ip_ex_WZ_H5pm_WZ_lnull_2_CMS13(double mH5){
2520  int NumPar = 1;
2521  double params[] = {mH5};
2522 
2523  int i = CacheCheckReal(ip_ex_WZ_H5pm_WZ_lnull_2_CMS13_cache, NumPar, params);
2524  if (i>=0) {
2525  return ( ip_ex_WZ_H5pm_WZ_lnull_2_CMS13_cache[NumPar][i] );
2526  } else {
2527  double newResult = interpolate(CMS13_WZ_H5pm_WZ_lnull_2,mH5);
2528  CacheShiftReal(ip_ex_WZ_H5pm_WZ_lnull_2_CMS13_cache, NumPar, params, newResult);
2529  return newResult;
2530  }
2531 }
2532 
2533 double GMcache::ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8(double mH5){
2534  int NumPar = 1;
2535  double params[] = {mH5};
2536 
2537  int i = CacheCheckReal(ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8_cache, NumPar, params);
2538  if (i>=0) {
2539  return ( ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8_cache[NumPar][i] );
2540  } else {
2541  double newResult = interpolate(ATLAS8_pp_H5ppmmH5mmpp_eeee,mH5);
2542  CacheShiftReal(ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8_cache, NumPar, params, newResult);
2543  return newResult;
2544  }
2545 }
2546 
2547 double GMcache::ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8(double mH5){
2548  int NumPar = 1;
2549  double params[] = {mH5};
2550 
2551  int i = CacheCheckReal(ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8_cache, NumPar, params);
2552  if (i>=0) {
2553  return ( ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8_cache[NumPar][i] );
2554  } else {
2555  double newResult = interpolate(ATLAS8_pp_H5ppmmH5mmpp_emuemu,mH5);
2556  CacheShiftReal(ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8_cache, NumPar, params, newResult);
2557  return newResult;
2558  }
2559 }
2560 
2561 double GMcache::ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8(double mH5){
2562  int NumPar = 1;
2563  double params[] = {mH5};
2564 
2565  int i = CacheCheckReal(ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8_cache, NumPar, params);
2566  if (i>=0) {
2567  return ( ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8_cache[NumPar][i] );
2568  } else {
2569  double newResult = interpolate(ATLAS8_pp_H5ppmmH5mmpp_mumumumu,mH5);
2570  CacheShiftReal(ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8_cache, NumPar, params, newResult);
2571  return newResult;
2572  }
2573 }
2574 
2575 double GMcache::ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13(double mH5){
2576  int NumPar = 1;
2577  double params[] = {mH5};
2578 
2579  int i = CacheCheckReal(ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13_cache, NumPar, params);
2580  if (i>=0) {
2581  return ( ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13_cache[NumPar][i] );
2582  } else {
2583  double newResult = interpolate(ATLAS13_pp_H5ppmmH5mmpp_llll,mH5);
2584  CacheShiftReal(ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13_cache, NumPar, params, newResult);
2585  return newResult;
2586  }
2587 }
2588 
2589 double GMcache::ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13(double mH5){
2590  int NumPar = 1;
2591  double params[] = {mH5};
2592 
2593  int i = CacheCheckReal(ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13_cache, NumPar, params);
2594  if (i>=0) {
2595  return ( ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13_cache[NumPar][i] );
2596  } else {
2597  double newResult = interpolate(ATLAS13_pp_H5ppmmH5mmpp_WWWW,mH5);
2598  CacheShiftReal(ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13_cache, NumPar, params, newResult);
2599  return newResult;
2600  }
2601 }
2602 
2603 double GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS8(double mH5){
2604  int NumPar = 1;
2605  double params[] = {mH5};
2606 
2607  int i = CacheCheckReal(ip_ex_VV_H5ppmm_WW_jjll_CMS8_cache, NumPar, params);
2608  if (i>=0) {
2609  return ( ip_ex_VV_H5ppmm_WW_jjll_CMS8_cache[NumPar][i] );
2610  } else {
2611  double newResult = interpolate(CMS8_VV_H5ppmm_WW_jjll,mH5);
2612  CacheShiftReal(ip_ex_VV_H5ppmm_WW_jjll_CMS8_cache, NumPar, params, newResult);
2613  return newResult;
2614  }
2615 }
2616 
2617 double GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS13(double mH5){
2618  int NumPar = 1;
2619  double params[] = {mH5};
2620 
2621  int i = CacheCheckReal(ip_ex_VV_H5ppmm_WW_jjll_CMS13_cache, NumPar, params);
2622  if (i>=0) {
2623  return ( ip_ex_VV_H5ppmm_WW_jjll_CMS13_cache[NumPar][i] );
2624  } else {
2625  double newResult = interpolate(CMS13_VV_H5ppmm_WW_jjll,mH5);
2626  CacheShiftReal(ip_ex_VV_H5ppmm_WW_jjll_CMS13_cache, NumPar, params, newResult);
2627  return newResult;
2628  }
2629 }
2630 
2631 
2632 
2633 
2634 void GMcache::readTable(gslpp::matrix<double>& arrayTab, std::string filename, int rowN, int colN){
2635 
2636  std::ifstream INfile;
2637  std::string lineTab;
2638  INfile.open( filename.c_str() );
2639  if(INfile.fail()){
2640  std::cout<<"error: in GMcache, table doesn't exist!"<<std::endl;
2641  }
2642 
2643  int a=0;
2644  int b=0;
2645  double v;
2646 
2647  while(INfile.good()){
2648  while(getline(INfile, lineTab)){
2649  if( lineTab[0]=='#' )continue;
2650  else{
2651  std::istringstream streamTab(lineTab);
2652  b=0;
2653  while(streamTab >>v){
2654  arrayTab.assign(a,b,v);
2655  b++;
2656  }
2657  a++;
2658  }
2659  }
2660  }
2661 
2662  INfile.close();
2663 }
2664 
2665 //1D interpolation
2666 
2667 double GMcache::interpolate(gslpp::matrix<double>& arrayTab, double x){
2668 
2669  int rowN=arrayTab.size_i();
2670 
2671  double xmin = arrayTab(0,0);
2672  double xmax = arrayTab(rowN-1,0);
2673  double interval = arrayTab(1,0)-arrayTab(0,0);
2674  int Nintervals = (x-xmin)/interval; //floor!
2675  double y = 0.0;
2676 
2677  if(x<xmin){
2678 // std::cout<<"warning: your table parameter value is smaller than the minimum allowed value"<<std::endl;
2679  return 0.;
2680  }
2681  else if(x>=xmax){
2682 // std::cout<<"warning: your table parameter value is greater than the maximum allowed value"<<std::endl;
2683  return 0.;
2684  }
2685  else{
2686  y =(arrayTab(Nintervals+1,1)-arrayTab(Nintervals,1))/interval*(x-arrayTab(Nintervals,0))
2687  +arrayTab(Nintervals,1);
2688  return y;
2689  }
2690 }
2691 
2692 //2D interpolation
2693 
2694 double GMcache::interpolate2D(gslpp::matrix<double>& arrayTab, double x, double y){
2695 
2696  int rowN=arrayTab.size_i();
2697 
2698  double xmin = arrayTab(0,0);
2699  double xmax = arrayTab(rowN-1,0);
2700  double ymin = arrayTab(0,1);
2701  double ymax = arrayTab(rowN-1,1);
2702  double intervalx = arrayTab(1,0)-arrayTab(0,0);
2703  int i=1;
2704  do i++;
2705  while(arrayTab(i,1)-arrayTab(i-1,1)==0&&i<30000);
2706  double intervaly = arrayTab(i,1)-arrayTab(i-1,1);
2707  int Nintervalsx = (x-xmin)/intervalx;
2708  int Nintervalsy = (y-ymin)/intervaly;
2709  if(x<xmin||x>xmax||y<ymin||y>ymax){
2710 // std::cout<<"warning: the parameter point lies outside the table"<<std::endl;
2711  return 0.;
2712  }
2713  else{
2714  double x1=arrayTab(i*Nintervalsy+Nintervalsx,0);
2715  double x2=arrayTab(i*Nintervalsy+Nintervalsx+1,0);
2716  double y1=arrayTab(i*Nintervalsy+Nintervalsx,1);
2717  double y2=arrayTab(i*(Nintervalsy+1)+Nintervalsx,1);
2718  return (arrayTab(i*Nintervalsy+Nintervalsx,2) * (x2-x) * (y2-y)
2719  +arrayTab(i*Nintervalsy+Nintervalsx+1,2) * (x-x1) * (y2-y)
2720  +arrayTab(i*(Nintervalsy+1)+Nintervalsx,2) * (x2-x) * (y-y1)
2721  +arrayTab(i*(Nintervalsy+1)+Nintervalsx+1,2) * (x-x1) * (y-y1))
2722  /((x2-x1)*(y2-y1));
2723  }
2724 }
2725 
2726 
2727 gslpp::complex GMcache::I_h_U(const double mHl2, const double Mu, const double Mc, const double Mt) const {
2728  int NumPar = 4;
2729  double params[] = {mHl2, Mu, Mc, Mt};
2730 
2731  int i = CacheCheck(I_h_U_cache, NumPar, params);
2732  if (i>=0) {
2733  return ( I_h_U_cache[NumPar][i] );
2734  } else {
2735  double TAUu=4.0*Mu*Mu/mHl2;
2736  double TAUc=4.0*Mc*Mc/mHl2;
2737  double TAUt=4.0*Mt*Mt/mHl2;
2738  gslpp::complex newResult = -(8./3.)*(TAUu*(1.0+(1.0-TAUu)*f_func(TAUu))
2739  +TAUc*(1.0+(1.0-TAUc)*f_func(TAUc))+TAUt*(1.0+(1.0-TAUt)*f_func(TAUt)));
2740  CacheShift(I_h_U_cache, NumPar, params, newResult);
2741  return newResult;
2742  }
2743 }
2744 
2745 gslpp::complex GMcache::I_HH_U(const double mHh2, const double Mc, const double Mt) const {
2746  int NumPar = 3;
2747  double params[] = {mHh2, Mc, Mt};
2748 
2749  int i = CacheCheck(I_HH_U_cache, NumPar, params);
2750  if (i>=0) {
2751  return ( I_HH_U_cache[NumPar][i] );
2752  } else {
2753  double TAUc=4.0*Mc*Mc/mHh2;
2754  double TAUt=4.0*Mt*Mt/mHh2;
2755  gslpp::complex newResult = -(8./3.)*(TAUc*(1.0+(1.0-TAUc)*f_func(TAUc))
2756  +TAUt*(1.0+(1.0-TAUt)*f_func(TAUt)));
2757  CacheShift(I_HH_U_cache, NumPar, params, newResult);
2758  return newResult;
2759  }
2760 }
2761 
2762 gslpp::complex GMcache::I_A_U(const double mA2, const double Mc, const double Mt) const {
2763  int NumPar = 3;
2764  double params[] = {mA2, Mc, Mt};
2765 
2766  int i = CacheCheck(I_A_U_cache, NumPar, params);
2767  if (i>=0) {
2768  return ( I_A_U_cache[NumPar][i] );
2769  } else {
2770  double TAUc=4.0*Mc*Mc/mA2;
2771  double TAUt=4.0*Mt*Mt/mA2;
2772  gslpp::complex newResult = -(8./3.)*(TAUc*f_func(TAUc)+TAUt*f_func(TAUt));
2773  CacheShift(I_A_U_cache, NumPar, params, newResult);
2774  return newResult;
2775  }
2776 }
2777 
2778 gslpp::complex GMcache::I_h_D(const double mHl2, const double Md, const double Ms, const double Mb) const {
2779  int NumPar = 4;
2780  double params[] = {mHl2, Md, Ms, Mb};
2781 
2782  int i = CacheCheck(I_h_D_cache, NumPar, params);
2783  if (i>=0) {
2784  return ( I_h_D_cache[NumPar][i] );
2785  } else {
2786  double TAUd=4.0*Md*Md/mHl2;
2787  double TAUs=4.0*Ms*Ms/mHl2;
2788  double TAUb=4.0*Mb*Mb/mHl2;
2789  gslpp::complex newResult = -(2./3.)*(TAUd*(1.0+(1.0-TAUd)*f_func(TAUd))
2790  +TAUs*(1.0+(1.0-TAUs)*f_func(TAUs))+TAUb*(1.0+(1.0-TAUb)*f_func(TAUb)));
2791  CacheShift(I_h_D_cache, NumPar, params, newResult);
2792  return newResult;
2793  }
2794 }
2795 
2796 gslpp::complex GMcache::I_HH_D(const double mHh2, const double Ms, const double Mb) const {
2797  int NumPar = 3;
2798  double params[] = {mHh2, Ms, Mb};
2799 
2800  int i = CacheCheck(I_HH_D_cache, NumPar, params);
2801  if (i>=0) {
2802  return ( I_HH_D_cache[NumPar][i] );
2803  } else {
2804  double TAUs=4.0*Ms*Ms/mHh2;
2805  double TAUb=4.0*Mb*Mb/mHh2;
2806  gslpp::complex newResult = -(2./3.)*(TAUs*(1.0+(1.0-TAUs)*f_func(TAUs))
2807  +TAUb*(1.0+(1.0-TAUb)*f_func(TAUb)));
2808  CacheShift(I_HH_D_cache, NumPar, params, newResult);
2809  return newResult;
2810  }
2811 }
2812 
2813 gslpp::complex GMcache::I_A_D(const double mA2, const double Ms, const double Mb) const {
2814  int NumPar = 3;
2815  double params[] = {mA2, Ms, Mb};
2816 
2817  int i = CacheCheck(I_A_D_cache, NumPar, params);
2818  if (i>=0) {
2819  return ( I_A_D_cache[NumPar][i] );
2820  } else {
2821  double TAUs=4.0*Ms*Ms/mA2;
2822  double TAUb=4.0*Mb*Mb/mA2;
2823  gslpp::complex newResult = -(2./3.)*(TAUs*f_func(TAUs)+TAUb*f_func(TAUb));
2824  CacheShift(I_A_D_cache, NumPar, params, newResult);
2825  return newResult;
2826  }
2827 }
2828 
2829 gslpp::complex GMcache::I_h_L(const double mHl2, const double Me, const double Mmu, const double Mtau) const {
2830  int NumPar = 4;
2831  double params[] = {mHl2, Me, Mmu, Mtau};
2832 
2833  int i = CacheCheck(I_h_L_cache, NumPar, params);
2834  if (i>=0) {
2835  return ( I_h_L_cache[NumPar][i] );
2836  } else {
2837  double TAUe=4.0*Me*Me/mHl2;
2838  double TAUmu=4.0*Mmu*Mmu/mHl2;
2839  double TAUtau=4.0*Mtau*Mtau/mHl2;
2840  gslpp::complex newResult = -2.0*(TAUe*(1.0+(1.0-TAUe)*f_func(TAUe))
2841  +TAUmu*(1.0+(1.0-TAUmu)*f_func(TAUmu))
2842  +TAUtau*(1.0+(1.0-TAUtau)*f_func(TAUtau)));
2843  CacheShift(I_h_L_cache, NumPar, params, newResult);
2844  return newResult;
2845  }
2846 }
2847 
2848 gslpp::complex GMcache::I_HH_L(const double mHh2, const double Mmu, const double Mtau) const {
2849  int NumPar = 3;
2850  double params[] = {mHh2, Mmu, Mtau};
2851 
2852  int i = CacheCheck(I_HH_L_cache, NumPar, params);
2853  if (i>=0) {
2854  return ( I_HH_L_cache[NumPar][i] );
2855  } else {
2856  double TAUmu=4.0*Mmu*Mmu/mHh2;
2857  double TAUtau=4.0*Mtau*Mtau/mHh2;
2858  gslpp::complex newResult = -2.0*(TAUmu*(1.0+(1.0-TAUmu)*f_func(TAUmu))+
2859  TAUtau*(1.0+(1.0-TAUtau)*f_func(TAUtau)));
2860  CacheShift(I_HH_L_cache, NumPar, params, newResult);
2861  return newResult;
2862  }
2863 }
2864 
2865 gslpp::complex GMcache::I_A_L(const double mA2, const double Mmu, const double Mtau) const {
2866  int NumPar = 3;
2867  double params[] = {mA2, Mmu, Mtau};
2868 
2869  int i = CacheCheck(I_A_L_cache, NumPar, params);
2870  if (i>=0) {
2871  return ( I_A_L_cache[NumPar][i] );
2872  } else {
2873  double TAUmu=4.0*Mmu*Mmu/mA2;
2874  double TAUtau=4.0*Mtau*Mtau/mA2;
2875  gslpp::complex newResult = -2.0*(TAUmu*f_func(TAUmu)+TAUtau*f_func(TAUtau));
2876  CacheShift(I_A_L_cache, NumPar, params, newResult);
2877  return newResult;
2878  }
2879 }
2880 
2881 gslpp::complex GMcache::I_H_W(const double mH, const double MW) const {
2882  int NumPar = 2;
2883  double params[] = {mH, MW};
2884 
2885  int i = CacheCheck(I_H_W_cache, NumPar, params);
2886  if (i>=0) {
2887  return ( I_H_W_cache[NumPar][i] );
2888  } else {
2889  double TAUw=4.0*MW*MW/(mH*mH);
2890  gslpp::complex newResult = 2.0 + 3.0*TAUw + 3.0*TAUw*(2.0-TAUw)*f_func(TAUw);
2891  CacheShift(I_H_W_cache, NumPar, params, newResult);
2892  return newResult;
2893  }
2894 }
2895 
2896 gslpp::complex GMcache::I_H_Hp(const double mHp2, const double mH) const {
2897  int NumPar = 2;
2898  double params[] = {mHp2, mH};
2899 
2900  int i = CacheCheck(I_H_Hp_cache, NumPar, params);
2901  if (i>=0) {
2902  return ( I_H_Hp_cache[NumPar][i] );
2903  } else {
2904  double TAUhp=4.0*mHp2/(mH*mH);
2905  gslpp::complex newResult = -TAUhp*(1.0-TAUhp*f_func(TAUhp));
2906  CacheShift(I_H_Hp_cache, NumPar, params, newResult);
2907  return newResult;
2908  }
2909 }
2910 
2911 gslpp::complex GMcache::A_h_U(const double mHl2, const double cW2, const double Mu, const double Mc, const double Mt, const double MZ) const {
2912  int NumPar = 6;
2913  double params[] = {mHl2, cW2, Mu, Mc, Mt, MZ};
2914 
2915  int i = CacheCheck(A_h_U_cache, NumPar, params);
2916  if (i>=0) {
2917  return ( A_h_U_cache[NumPar][i] );
2918  } else {
2919  double TAUu=4.0*Mu*Mu/mHl2;
2920  double TAUc=4.0*Mc*Mc/mHl2;
2921  double TAUt=4.0*Mt*Mt/mHl2;
2922  double LAMu=4.0*Mu*Mu/(MZ*MZ);
2923  double LAMc=4.0*Mc*Mc/(MZ*MZ);
2924  double LAMt=4.0*Mt*Mt/(MZ*MZ);
2925  double sW2=1.0-cW2;
2926  gslpp::complex newResult = -4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUu,LAMu)+Int1(TAUc,LAMc)
2927  +Int1(TAUt,LAMt)-Int2(TAUu,LAMu)-Int2(TAUc,LAMc)-Int2(TAUt,LAMt));
2928  CacheShift(A_h_U_cache, NumPar, params, newResult);
2929  return newResult;
2930  }
2931 }
2932 
2933 gslpp::complex GMcache::A_HH_U(const double mHh2, const double cW2, const double Mc, const double Mt, const double MZ) const {
2934  int NumPar = 5;
2935  double params[] = {mHh2, cW2, Mc, Mt, MZ};
2936 
2937  int i = CacheCheck(A_HH_U_cache, NumPar, params);
2938  if (i>=0) {
2939  return ( A_HH_U_cache[NumPar][i] );
2940  } else {
2941  double TAUc=4.0*Mc*Mc/mHh2;
2942  double TAUt=4.0*Mt*Mt/mHh2;
2943  double LAMc=4.0*Mc*Mc/(MZ*MZ);
2944  double LAMt=4.0*Mt*Mt/(MZ*MZ);
2945  double sW2=1.0-cW2;
2946  gslpp::complex newResult = -4.0*(0.5-4.0/3.0*sW2)*(Int1(TAUc,LAMc)-Int2(TAUc,LAMc)
2947  +Int1(TAUt,LAMt)-Int2(TAUt,LAMt));
2948  CacheShift(A_HH_U_cache, NumPar, params, newResult);
2949  return newResult;
2950  }
2951 }
2952 
2953 gslpp::complex GMcache::A_A_U(const double mA2, const double cW2, const double Mc, const double Mt, const double MZ) const {
2954  int NumPar = 5;
2955  double params[] = {mA2, cW2, Mc, Mt, MZ};
2956 
2957  int i = CacheCheck(A_A_U_cache, NumPar, params);
2958  if (i>=0) {
2959  return ( A_A_U_cache[NumPar][i] );
2960  } else {
2961  double TAUc=4.0*Mc*Mc/mA2;
2962  double TAUt=4.0*Mt*Mt/mA2;
2963  double LAMc=4.0*Mc*Mc/(MZ*MZ);
2964  double LAMt=4.0*Mt*Mt/(MZ*MZ);
2965  double sW2=1.0-cW2;
2966  gslpp::complex newResult = -4.0*(0.5-4.0/3.0*sW2)*(-Int2(TAUc,LAMc)-Int2(TAUt,LAMt))/sqrt(sW2*cW2);
2967  CacheShift(A_A_U_cache, NumPar, params, newResult);
2968  return newResult;
2969  }
2970 }
2971 
2972 gslpp::complex GMcache::A_h_D(const double mHl2, const double cW2, const double Md, const double Ms, const double Mb, const double MZ) const {
2973  int NumPar = 6;
2974  double params[] = {mHl2, cW2, Md, Ms, Mb, MZ};
2975 
2976  int i = CacheCheck(A_h_D_cache, NumPar, params);
2977  if (i>=0) {
2978  return ( A_h_D_cache[NumPar][i] );
2979  } else {
2980  double TAUd=4.0*Md*Md/mHl2;
2981  double TAUs=4.0*Ms*Ms/mHl2;
2982  double TAUb=4.0*Mb*Mb/mHl2;
2983  double LAMd=4.0*Md*Md/(MZ*MZ);
2984  double LAMs=4.0*Ms*Ms/(MZ*MZ);
2985  double LAMb=4.0*Mb*Mb/(MZ*MZ);
2986  double sW2=1.0-cW2;
2987  gslpp::complex newResult = 2.0*(-0.5+2.0/3.0*sW2)*(Int1(TAUd,LAMd)+Int1(TAUs,LAMs)
2988  +Int1(TAUb,LAMb)-Int2(TAUd,LAMd)-Int2(TAUs,LAMs)-Int2(TAUb,LAMb));
2989  CacheShift(A_h_D_cache, NumPar, params, newResult);
2990  return newResult;
2991  }
2992 }
2993 
2994 gslpp::complex GMcache::A_HH_D(const double mHh2, const double cW2, const double Ms, const double Mb, const double MZ) const {
2995  int NumPar = 5;
2996  double params[] = {mHh2, cW2, Ms, Mb, MZ};
2997 
2998  int i = CacheCheck(A_HH_D_cache, NumPar, params);
2999  if (i>=0) {
3000  return ( A_HH_D_cache[NumPar][i] );
3001  } else {
3002  double TAUs=4.0*Ms*Ms/mHh2;
3003  double TAUb=4.0*Mb*Mb/mHh2;
3004  double LAMs=4.0*Ms*Ms/(MZ*MZ);
3005  double LAMb=4.0*Mb*Mb/(MZ*MZ);
3006  double sW2=1.0-cW2;
3007  gslpp::complex newResult = 2.0*(-0.5+2.0/3.0*sW2)*(Int1(TAUs,LAMs)-Int2(TAUs,LAMs)
3008  +Int1(TAUb,LAMb)-Int2(TAUb,LAMb));
3009  CacheShift(A_HH_D_cache, NumPar, params, newResult);
3010  return newResult;
3011  }
3012 }
3013 
3014 gslpp::complex GMcache::A_A_D(const double mA2, const double cW2, const double Ms, const double Mb, const double MZ) const {
3015  int NumPar = 5;
3016  double params[] = {mA2, cW2, Ms, Mb, MZ};
3017 
3018  int i = CacheCheck(A_A_D_cache, NumPar, params);
3019  if (i>=0) {
3020  return ( A_A_D_cache[NumPar][i] );
3021  } else {
3022  double TAUs=4.0*Ms*Ms/mA2;
3023  double TAUb=4.0*Mb*Mb/mA2;
3024  double LAMs=4.0*Ms*Ms/(MZ*MZ);
3025  double LAMb=4.0*Mb*Mb/(MZ*MZ);
3026  double sW2=1.0-cW2;
3027  gslpp::complex newResult = 2.0*(-0.5+2.0/3.0*sW2)*(-Int2(TAUs,LAMs)-Int2(TAUb,LAMb))/sqrt(sW2*cW2);
3028  CacheShift(A_A_D_cache, NumPar, params, newResult);
3029  return newResult;
3030  }
3031 }
3032 
3033 gslpp::complex GMcache::A_h_L(const double mHl2, const double cW2, const double Me, const double Mmu, const double Mtau, const double MZ) const {
3034  int NumPar = 6;
3035  double params[] = {mHl2, cW2, Me, Mmu, Mtau, MZ};
3036 
3037  int i = CacheCheck(A_h_L_cache, NumPar, params);
3038  if (i>=0) {
3039  return ( A_h_L_cache[NumPar][i] );
3040  } else {
3041  double TAUe=4.0*Me*Me/mHl2;
3042  double TAUmu=4.0*Mmu*Mmu/mHl2;
3043  double TAUtau=4.0*Mtau*Mtau/mHl2;
3044  double LAMe=4.0*Me*Me/(MZ*MZ);
3045  double LAMmu=4.0*Mmu*Mmu/(MZ*MZ);
3046  double LAMtau=4.0*Mtau*Mtau/(MZ*MZ);
3047  double sW2=1.0-cW2;
3048  gslpp::complex newResult = 2.0*(-0.5+2.0*sW2)*(Int1(TAUe,LAMe)+Int1(TAUmu,LAMmu)
3049  +Int1(TAUtau,LAMtau)-Int2(TAUe,LAMe)-Int2(TAUmu,LAMmu)
3050  -Int2(TAUtau,LAMtau));
3051  CacheShift(A_h_L_cache, NumPar, params, newResult);
3052  return newResult;
3053  }
3054 }
3055 
3056 gslpp::complex GMcache::A_HH_L(const double mHh2, const double cW2, const double Mmu, const double Mtau, const double MZ) const {
3057  int NumPar = 5;
3058  double params[] = {mHh2, cW2, Mmu, Mtau, MZ};
3059 
3060  int i = CacheCheck(A_HH_L_cache, NumPar, params);
3061  if (i>=0) {
3062  return ( A_HH_L_cache[NumPar][i] );
3063  } else {
3064  double TAUmu=4.0*Mmu*Mmu/mHh2;
3065  double TAUtau=4.0*Mtau*Mtau/mHh2;
3066  double LAMmu=4.0*Mmu*Mmu/(MZ*MZ);
3067  double LAMtau=4.0*Mtau*Mtau/(MZ*MZ);
3068  double sW2=1.0-cW2;
3069  gslpp::complex newResult = 2.0*(-0.5+2.0*sW2)*(Int1(TAUmu,LAMmu)-Int2(TAUmu,LAMmu)
3070  +Int1(TAUtau,LAMtau)-Int2(TAUtau,LAMtau));
3071  CacheShift(A_HH_L_cache, NumPar, params, newResult);
3072  return newResult;
3073  }
3074 }
3075 
3076 gslpp::complex GMcache::A_A_L(const double mA2, const double cW2, const double Mmu, const double Mtau, const double MZ) const {
3077  int NumPar = 5;
3078  double params[] = {mA2, cW2, Mmu, Mtau, MZ};
3079 
3080  int i = CacheCheck(A_A_L_cache, NumPar, params);
3081  if (i>=0) {
3082  return ( A_A_L_cache[NumPar][i] );
3083  } else {
3084  double TAUmu=4.0*Mmu*Mmu/mA2;
3085  double TAUtau=4.0*Mtau*Mtau/mA2;
3086  double LAMmu=4.0*Mmu*Mmu/(MZ*MZ);
3087  double LAMtau=4.0*Mtau*Mtau/(MZ*MZ);
3088  double sW2=1.0-cW2;
3089  gslpp::complex newResult = 2.0*(-0.5+2.0*sW2)*(-Int2(TAUmu,LAMmu)-Int2(TAUtau,LAMtau))/sqrt(sW2*cW2);
3090  CacheShift(A_A_L_cache, NumPar, params, newResult);
3091  return newResult;
3092  }
3093 }
3094 
3095 gslpp::complex GMcache::A_H_W(const double mH, const double cW2, const double MW, const double MZ) const {
3096  int NumPar = 4;
3097  double params[] = {mH, cW2, MW, MZ};
3098 
3099  int i = CacheCheck(A_H_W_cache, NumPar, params);
3100  if (i>=0) {
3101  return ( A_H_W_cache[NumPar][i] );
3102  } else {
3103  double TAUw=4.0*MW*MW/(mH*mH);
3104  double LAMw=4.0*MW*MW/(MZ*MZ);
3105  double sW2=1.0-cW2;
3106  gslpp::complex newResult = -sqrt(cW2/sW2)*(4.0*(3.0-sW2/cW2)*Int2(TAUw,LAMw)
3107  +((1.0+2.0/TAUw)*sW2/cW2-(5.0+2.0/TAUw))*Int1(TAUw,LAMw));
3108  CacheShift(A_H_W_cache, NumPar, params, newResult);
3109  return newResult;
3110  }
3111 }
3112 
3113 gslpp::complex GMcache::A_H_Hp(const double mHp2, const double mH, const double cW2, const double MZ) const {
3114  int NumPar = 4;
3115  double params[] = {mHp2, mH, cW2, MZ};
3116 
3117  int i = CacheCheck(A_H_Hp_cache, NumPar, params);
3118  if (i>=0) {
3119  return ( A_H_Hp_cache[NumPar][i] );
3120  } else {
3121  double TAUhp=4.0*mHp2/(mH*mH);
3122  double LAMhp=4.0*mHp2/(MZ*MZ);
3123  double sW2=1.0-cW2;
3124  gslpp::complex newResult = (1.0-2.0*sW2)/sqrt(cW2*sW2)*Int1(TAUhp,LAMhp);
3125  CacheShift(A_H_Hp_cache, NumPar, params, newResult);
3126  return newResult;
3127  }
3128 }
3129 
3130 gslpp::complex GMcache::f_func(const double x) const{
3131  if(x<1) {
3132  gslpp::complex z = -gslpp::complex::i()*M_PI;
3133  return -pow(log((1.0+sqrt(1.0-x))/(1.0-sqrt(1.0-x)))+z,2)/4.0;
3134  }
3135  else {
3136  return pow(asin(sqrt(1.0/x)),2);
3137  }
3138 }
3139 
3140 gslpp::complex GMcache::g_func(const double x) const{
3141  if(x<1) {
3142  gslpp::complex z = -gslpp::complex::i()*M_PI;
3143  gslpp::complex gs1 = sqrt(1.0-x)*(log((1.0+sqrt(1.0-x))/(1.0-sqrt(1.0-x)))+z)/2.0;
3144  return gs1;
3145  }
3146  else {
3147  gslpp::complex gg1 = sqrt(x-1.0)*asin(sqrt(1.0/x));
3148  return gg1;
3149  }
3150 }
3151 
3152 gslpp::complex GMcache::Int1(const double tau, const double lambda) const{
3153  return tau*lambda/(tau-lambda)/2.0+tau*tau*lambda*lambda/((tau-lambda)
3154  *(tau-lambda))/2.0*(f_func(tau)-f_func(lambda))+tau*tau*lambda/((tau-lambda)
3155  *(tau-lambda))*(g_func(tau)-g_func(lambda));
3156 }
3157 
3158 gslpp::complex GMcache::Int2(const double tau, const double lambda) const{
3159  return -tau*lambda/(tau-lambda)/2.0*(f_func(tau)-f_func(lambda));
3160 }
3161 
3162 void GMcache::computeSignalStrengthQuantities()
3163 {
3164  double Mt = myGM->getQuarks(QCD::TOP).getMass();
3165  double Mb = myGM->getQuarks(QCD::BOTTOM).getMass();
3166  double Mc = myGM->getQuarks(QCD::CHARM).getMass();
3167  double Ms = myGM->getQuarks(QCD::STRANGE).getMass();
3168  double Mu = myGM->getQuarks(QCD::UP).getMass();
3169  double Md = myGM->getQuarks(QCD::DOWN).getMass();
3170  double Mtau = myGM->getLeptons(StandardModel::TAU).getMass();
3171  double Mmu = myGM->getLeptons(StandardModel::MU).getMass();
3172  double Me = myGM->getLeptons(StandardModel::ELECTRON).getMass();
3173 
3174  double BrSM_htobb = myGM->computeBrHtobb();
3175  double BrSM_htotautau = myGM->computeBrHtotautau();
3176  double BrSM_htogaga = myGM->computeBrHtogaga();
3177  double BrSM_htoWW = myGM->computeBrHtoWW();
3178  double BrSM_htoZZ = myGM->computeBrHtoZZ();
3179  double BrSM_htogg = myGM->computeBrHtogg();
3180  double BrSM_htoZga = myGM->computeBrHtoZga();
3181  double BrSM_htocc = myGM->computeBrHtocc();
3182 
3183  double sW2=1.0-cW2;
3184 
3185 // depending on which Higgs is heavier
3186 
3187  double sqrtrh_ff=0., sqrtrh_VV=0., gh_H3=0., gh_H5=0.;
3188 
3189  if(mH1sq>=mHl2)
3190  {
3191  sqrtrh_ff = cosa/sinb;
3192  sqrtrh_VV = cosa*sinb - sqrt(8.0/3.0)*sina*cosb;
3193  gh_H3 = ghH3pH3m;
3194  gh_H5 = ghH5pH5m;
3195  }
3196  else
3197  {
3198  sqrtrh_ff = sina/sinb;
3199  sqrtrh_VV = sina*sinb + sqrt(8.0/3.0)*cosa*cosb;
3200  gh_H3 = gHH3pH3m;
3201  gh_H5 = gHH5pH5m;
3202  }
3203  rh_ff = sqrtrh_ff*sqrtrh_ff;
3204  rh_VV = sqrtrh_VV*sqrtrh_VV;
3205 
3206  //rh_gaga formula = abs(I_h_F+I_h_W+I_h_Hp)^2 / abs(I_hSM_F+I_hSM_W)^2
3207 
3208  gslpp::complex I_hSM_F = I_h_U(mHl2,Mu,Mc,Mt)+I_h_D(mHl2,Md,Ms,Mb)+I_h_L(mHl2,Me,Mmu,Mtau);
3209  gslpp::complex I_hSM_W = I_H_W(mHl,MW);
3210  gslpp::complex I_h_F = sqrtrh_ff*I_hSM_F;
3211  gslpp::complex I_h_W = sqrtrh_VV*I_hSM_W;
3212  gslpp::complex I_h_Hp = 0.5*vev*( gh_H3*I_H_Hp(mAsq,mHl)/mAsq + 5.0*gh_H5*I_H_Hp(mH5sq,mHl)/mH5sq );
3213 
3214  double ABSgagaGM=(I_h_F+I_h_W+I_h_Hp).abs2();
3215  double ABSgagaSM=(I_hSM_F+I_hSM_W).abs2();
3216  rh_gaga=ABSgagaGM/ABSgagaSM;
3217 
3218 // std::cout<<"I_h_F = "<<I_h_F<<std::endl;
3219 // std::cout<<"I_h_W = "<<I_h_W<<std::endl;
3220 // std::cout<<"I_h_Hp3 = "<<0.5*vev*( gh_H3*I_H_Hp(mAsq,mHl)/mAsq )<<std::endl;
3221 // std::cout<<"I_h_Hp5 = "<<0.5*vev*( 5.0*gh_H5*I_H_Hp(mH5sq,mHl)/mH5sq )<<std::endl;
3222 
3223  //rh_Zga formula = abs(A_h_F+A_h_W+A_h_Hp)^2 / abs(A_hSM_F+A_hSM_W)^2
3224 
3225  gslpp::complex A_hSM_F = A_h_U(mHl2,cW2,Mu,Mc,Mt,MZ)+A_h_D(mHl2,cW2,Md,Ms,Mb,MZ)+A_h_L(mHl2,cW2,Me,Mmu,Mtau,MZ);
3226  gslpp::complex A_hSM_W = A_H_W(mHl,cW2,MW,MZ);
3227  gslpp::complex A_h_F = sqrtrh_ff*A_hSM_F/sqrt(sW2*cW2);
3228  gslpp::complex A_h_W = sqrtrh_VV*A_hSM_W;
3229  gslpp::complex A_h_Hp = -0.5*vev*(gh_H3*A_H_Hp(mAsq,mHl,cW2,MZ)/mAsq + 5.0*gh_H5*A_H_Hp(mH5sq,mHl,cW2,MZ)/mH5sq);
3230 
3231  double ABSZgaGM=(A_h_F+A_h_W+A_h_Hp).abs2();
3232  double ABSZgaSM=(A_hSM_F+A_hSM_W).abs2();
3233  rh_Zga=ABSZgaGM/ABSZgaSM;
3234 
3235 // std::cout<<"A_h_F = "<<A_h_F<<std::endl;
3236 // std::cout<<"A_h_W = "<<A_h_W<<std::endl;
3237 // std::cout<<"A_h_Hp3 = "<<-0.5*vev*(gh_H3*A_H_Hp(mAsq,mHl,cW2,MZ)/mAsq)<<std::endl;
3238 // std::cout<<"A_h_Hp5 = "<<-0.5*vev*(5.0*gh_H5*A_H_Hp(mH5sq,mHl,cW2,MZ)/mH5sq)<<std::endl;
3239 
3240  rh_gg=rh_ff;
3241 
3242  sumModBRs = rh_ff*(BrSM_htobb+BrSM_htotautau+BrSM_htocc) + rh_VV*(BrSM_htoWW+BrSM_htoZZ)
3243  + rh_gaga*BrSM_htogaga + rh_gg*BrSM_htogg + rh_Zga*BrSM_htoZga;
3244 
3245  Gamma_h = sumModBRs*myGM->computeGammaHTotal();
3246 
3247 // std::cout<<"Gamma_hff = "<<rh_ff*(BrSM_htobb+BrSM_htotautau+BrSM_htocc)*myGM->computeGammaHTotal()<<std::endl;
3248 // std::cout<<"Gamma_hVV = "<<rh_VV*(BrSM_htoWW+BrSM_htoZZ) *myGM->computeGammaHTotal()<<std::endl;
3249 // std::cout<<"Gamma_hgaga = "<<rh_gaga*BrSM_htogaga*myGM->computeGammaHTotal()<<std::endl;
3250 // std::cout<<"Gamma_hgg = "<<rh_gg*BrSM_htogg*myGM->computeGammaHTotal()<<std::endl;
3251 // std::cout<<"Gamma_hZga = "<<rh_Zga*BrSM_htoZga*myGM->computeGammaHTotal()<<std::endl;
3252 // std::cout<<"Gamma_h = "<<Gamma_h<<std::endl;
3253 
3254  GM_Br_h_bb = rh_ff*BrSM_htobb/sumModBRs;
3255  GM_Br_h_gaga = rh_gaga*BrSM_htogaga/sumModBRs;
3256  GM_Br_h_tautau = rh_ff*BrSM_htotautau/sumModBRs;
3257  GM_Br_h_WW = rh_VV*BrSM_htoWW/sumModBRs;
3258  GM_Br_h_ZZ = rh_VV*BrSM_htoZZ/sumModBRs;
3259 }
3260 
3261 double GMcache::HSTheta (const double x) const{
3262  if(x<0) return 0.0;
3263  else if(x==0) return 0.5;
3264  else return 1.0;
3265 }
3266 
3267 double GMcache::KaellenFunction(const double a2, const double b2, const double c2) const{
3268  int NumPar = 3;
3269  double params[] = {a2, b2, c2};
3270 
3271  int i = CacheCheckReal(KaellenFunction_cache, NumPar, params);
3272  if (i>=0) {
3273  return ( KaellenFunction_cache[NumPar][i] );
3274  }
3275  else {
3276  double newResult = 0.0;
3277  double x = (a2-b2-c2)*(a2-b2-c2)-4.0*b2*c2;
3278  if(x>0) newResult = sqrt(std::fabs(x/a2))/2.0;
3279  CacheShiftReal(KaellenFunction_cache, NumPar, params, newResult);
3280  return newResult;
3281  }
3282 }
3283 
3284 double GMcache::OffShellFunction(const double k) const{
3285  int NumPar = 1;
3286  double params[] = {k};
3287 
3288  int i = CacheCheckReal(OffShellFunction_cache, NumPar, params);
3289  if (i>=0) {
3290  return ( OffShellFunction_cache[NumPar][i] );
3291  }
3292  else {
3293  double newResult=0.0;
3294  if(k>0.25) {
3295  newResult = (((1.0-8.0*k+20.0*k*k)/sqrt(fabs(4.0*k-1.0)))*acos(HSTheta(k-0.25)*(3.0*k-1.0)/(2.0*k*sqrt(k)))
3296  -(1.0-k)/(6.0*k)*(2.0-13.0*k+47.0*k*k) - 0.5*(1.0-6.0*k+4.0*k*k)*log(k));
3297  }
3298  CacheShiftReal(OffShellFunction_cache, NumPar, params, newResult);
3299  return newResult;
3300  }
3301 }
3302 
3303 void GMcache::computeOtherHiggsProperties()
3304 {
3305  double Als=myGM->getAlsMz();
3306  double sW2=1.0-cW2;
3307  double mHh=sqrt(mH1sq);
3308  double mA=sqrt(mAsq);
3309  double mH5=sqrt(mH5sq);
3310  double Mt = myGM->getQuarks(QCD::TOP).getMass();
3311  double MtPole = myGM->getMtpole();
3312  double Mb = myGM->getQuarks(QCD::BOTTOM).getMass();
3313  double Mc = myGM->getQuarks(QCD::CHARM).getMass();
3314  double Ms = myGM->getQuarks(QCD::STRANGE).getMass();
3315 // double Mu = myGM->getQuarks(QCD::UP).getMass();
3316 // double Md = myGM->getQuarks(QCD::DOWN).getMass();
3317  double Mtau = myGM->getLeptons(StandardModel::TAU).getMass();
3318  double Mmu = myGM->getLeptons(StandardModel::MU).getMass();
3319 // double Me = myGM->getLeptons(StandardModel::ELECTRON).getMass();
3320 
3321 // /* rX_ii is the squared ratio between the GM vertex coupling of the neutral heavy Higgs X to
3322 // * the particle i and the corresponding coupling of the SM Higgs boson.*/
3323  double rA_ff=1.0/(tanb*tanb);
3324 
3325  double sqrtrHH_ff=0., sqrtrHH_VV=0., gHH_H3=0., gHH_H5=0.;
3326 
3327  if(mH1sq>=mHl2)
3328  {
3329  sqrtrHH_ff = sina/sinb;
3330  sqrtrHH_VV = sina*sinb + sqrt(8.0/3.0)*cosa*cosb;
3331  gHH_H3 = gHH3pH3m;
3332  gHH_H5 = gHH5pH5m;
3333  }
3334  else
3335  {
3336  sqrtrHH_ff = cosa/sinb;
3337  sqrtrHH_VV = cosa*sinb - sqrt(8.0/3.0)*sina*cosb;
3338  gHH_H3 = ghH3pH3m;
3339  gHH_H5 = ghH5pH5m;
3340  }
3341  rHH_ff = sqrtrHH_ff*sqrtrHH_ff;
3342  rHH_VV = sqrtrHH_VV*sqrtrHH_VV;
3343 
3344  gslpp::complex I_HH_F=0.0;//It depends on the modelType
3345  gslpp::complex I_HH_Ux=I_HH_U(mH1sq,Mc,Mt);
3346  gslpp::complex I_HH_Dx=I_HH_D(mH1sq,Ms,Mb);
3347  gslpp::complex I_HH_Lx=I_HH_L(mH1sq,Mmu,Mtau);
3348  gslpp::complex I_HH_W=sqrtrHH_VV*I_H_W(mHh,MW);
3349  gslpp::complex I_HH_Hp = 0.5*vev*( gHH_H3*I_H_Hp(mAsq,mHh)/mAsq + 5.0*gHH_H5*I_H_Hp(mH5sq,mHh)/mH5sq );
3350 
3351  // /*A_HH_F, A_HH_W and A_HH_Hp are needed for Gamma_HZga;
3352 // * their expressions can be found in "The Higgs Hunter's Guide", Appendix C, C.12*/
3353  gslpp::complex A_HH_F = 0.0;//It depends on the modelType
3354  gslpp::complex A_HH_Ux = A_HH_U(mH1sq,cW2,Mc,Mt,MZ);
3355  gslpp::complex A_HH_Dx = A_HH_D(mH1sq,cW2,Ms,Mb,MZ);
3356  gslpp::complex A_HH_Lx = A_HH_L(mH1sq,cW2,Mmu,Mtau,MZ);
3357 // /*A_HH_W expression can be found in "The Higgs Hunter's Guide", Appendix C, C.13*/
3358  gslpp::complex A_HH_W = sqrtrHH_VV*A_H_W(mHh,cW2,MW,MZ);
3359 // /*A_HH_Hp expression can be found in "The Higgs Hunter's Guide", Appendix C, C.14*/
3360  gslpp::complex A_HH_Hp = -0.5*vev*(gHH_H3*A_H_Hp(mAsq,mHh,cW2,MZ)/mAsq + 5.0*gHH_H5*A_H_Hp(mH5sq,mHh,cW2,MZ)/mH5sq);
3361 
3362  I_HH_F=sqrtrHH_ff*(I_HH_Ux+I_HH_Dx+I_HH_Lx);
3363  A_HH_F=sqrtrHH_ff*(A_HH_Ux+A_HH_Dx+A_HH_Lx)/sqrt(sW2*cW2);
3364  /*Gamma_Hgaga expression can be found in arXiv:1412.7387, eq. (65)*/
3365  double Gamma_Hgaga=Ale*Ale*mH1sq*mHh/(256.0*M_PI*M_PI*M_PI*vev*vev)
3366  *(I_HH_F+I_HH_W+I_HH_Hp).abs2();
3367 // std::cout<<"I_HH_F = "<<I_HH_F<<std::endl;
3368 // std::cout<<"I_HH_W = "<<I_HH_W<<std::endl;
3369 // std::cout<<"I_HH_Hp3 = "<<0.5*vev*( gHH_H3*I_H_Hp(mAsq,mHh)/mAsq)<<std::endl;
3370 // std::cout<<"I_HH_Hp5 = "<<0.5*vev*(5.0*gHH_H5*I_H_Hp(mH5sq,mHh)/mH5sq )<<std::endl;
3371 
3372 // /*Gamma_HZga expression can be found in arXiv:1412.7387, eq. (76)*/
3373  double Gamma_HZga=HSTheta(mHh-MZ)*Ale*Ale*mH1sq*mHh/(128.0*M_PI*M_PI*M_PI*vev*vev)
3374  *(1.0-MZ*MZ/mH1sq)*(1.0-MZ*MZ/mH1sq)*(1.0-MZ*MZ/mH1sq)
3375  *(A_HH_F+A_HH_W+A_HH_Hp).abs2();
3376 // std::cout<<"A_HH_F = "<<A_HH_F<<std::endl;
3377 // std::cout<<"A_HH_W = "<<A_HH_W<<std::endl;
3378 // std::cout<<"A_HH_Hp3 = "<<-0.5*vev*(gHH_H3*A_H_Hp(mAsq,mHh,cW2,MZ)/mAsq)<<std::endl;
3379 // std::cout<<"A_HH_Hp5 = "<<-0.5*vev*( 5.0*gHH_H5*A_H_Hp(mH5sq,mHh,cW2,MZ)/mH5sq)<<std::endl;
3380 
3381  rHH_gg=rHH_ff;
3382  /*Gamma_Hgg expression can be found in arXiv:0902.4665v3, Appendix A, A.10 or in the Higgs Hunter's Guide (2.30); relative coupling see above*/
3383  double Gamma_Hgg=rHH_gg*GF*Als*Als*mHh*mH1sq/(sqrt(2.0)*16.0*M_PI*M_PI*M_PI)
3384  *(9.0/4.0)*(I_HH_Ux/4.0+I_HH_Dx).abs2();
3385 
3386  gslpp::complex I_A_F=sqrt(rA_ff)*(I_A_U(mAsq,Mc,Mt)+I_A_D(mAsq,Ms,Mb)+I_A_L(mAsq,Mmu,Mtau));
3387  gslpp::complex A_A_F=sqrt(rA_ff)*(A_A_U(mAsq,cW2,Mc,Mt,MZ)+A_A_D(mAsq,cW2,Ms,Mb,MZ)+A_A_L(mAsq,cW2,Mmu,Mtau,MZ));
3388  double Gamma_Agaga=Ale*Ale*mAsq*mA/(256.0*M_PI*M_PI*M_PI*vev*vev)
3389  *(I_A_F).abs2();
3390 // std::cout<<"I_A_F = "<<I_A_F<<std::endl;
3391  double Gamma_AZga=HSTheta(mA-MZ)*Ale*Ale*mAsq*mA/(128.0*M_PI*M_PI*M_PI*vev*vev)
3392  *(1.0-MZ*MZ/(mA*mA))*(1.0-MZ*MZ/(mA*mA))*(1.0-MZ*MZ/(mA*mA))
3393  *(A_A_F).abs2();
3394 // std::cout<<"A_A_F = "<<A_A_F<<std::endl;
3395  double Gamma_Agg=rA_ff*GF*Als*Als*mA*mAsq/(sqrt(2.0)*16.0*M_PI*M_PI*M_PI)
3396  *(9.0/4.0)*(I_A_U(mAsq,Mc,Mt)/4.0+I_A_D(mAsq,Ms,Mb)).abs2();
3397 
3398  double Gamma_Att=HSTheta(mA-2.0*MtPole)*rA_ff*3.0*Mt*Mt*sqrt(fabs(mAsq-4.0*MtPole*MtPole))/(8.0*M_PI*vev*vev);
3399 
3400  gslpp::complex A_H5_W = cosb/sqrt(3.0)*A_H_W(mH5,cW2,MW,MZ);
3401  gslpp::complex A_H5_Hp = -0.5*vev*(gH5H3pH3m*A_H_Hp(mAsq,mH5,cW2,MZ)/mAsq + 5.0*gH5H5pH5m*A_H_Hp(mH5sq,mH5,cW2,MZ)/mH5sq);
3402  double Gamma_H5gaga=Ale*Ale*mH5sq*mH5/(256.0*M_PI*M_PI*M_PI*vev*vev)*(
3403  cosb/sqrt(3.0)*I_H_W(mH5,MW)
3404  +0.5*(gH5H3pH3m*vev/mAsq)*I_H_Hp(mAsq,mH5)
3405  +14.0*(M_PI*M_PI/9.0-1.0)*(gH5H5pH5m*vev/mH5sq)).abs2();
3406 // std::cout<<"I_H5_W = "<<cosb/sqrt(3.0)*I_H_W(mH5,MW)<<std::endl;
3407 // std::cout<<"I_H5_Hp3 = "<<0.5*(gH5H3pH3m*vev/mAsq)*I_H_Hp(mAsq,mH5)<<std::endl;
3408 // std::cout<<"I_H5_Hp5 = "<<14.0*(M_PI*M_PI/9.0-1.0)*(gH5H5pH5m*vev/mH5sq)<<std::endl;
3409 // std::cout<<"g55p5m = "<<gH5H5pH5m<<std::endl;
3410  double Gamma_H5gg=0.0;
3411  double Gamma_H5Zga=HSTheta(mH5-MZ)*Ale*Ale*mH5sq*mH5/(128.0*M_PI*M_PI*M_PI*vev*vev)
3412  *(1.0-MZ*MZ/mH5sq)*(1.0-MZ*MZ/mH5sq)*(1.0-MZ*MZ/mH5sq)
3413  *(A_H5_W+A_H5_Hp).abs2();
3414 
3415  SigmaggF_H8=ip_cs_ggtoH_8(mHh)*rHH_ff;
3416  SigmaggF_A8=ip_cs_ggtoA_8(mA)*rA_ff;
3417  SigmabbF_H8=ip_cs_pptobbH_8(mHh)*rHH_ff;
3418  SigmabbF_A8=ip_cs_pptobbA_8(mA)*rA_ff;
3419  SigmaVBF_H8=ip_cs_VBFtoH_8(mHh)*rHH_VV;
3420  SigmaVBF_H58=ip_cs_VBFH5_8(mH5)*cosb*cosb;
3421  double SigmattF_H8=ip_cs_pptottH_8(mHh)*rHH_ff;
3422  double SigmattF_A8=ip_cs_pptottA_8(mA)*rA_ff;
3423  double SigmaVH_H8=(ip_cs_WtoWH_8(mHh)+ip_cs_ZtoZH_8(mHh))*rHH_VV;
3424  double SigmaVH_H58=ip_cs_VHH5_8(mH5)*cosb*cosb;
3425  SigmaTotSM_H8 = 1.0e-15;
3426  SigmaTotSM_H58 = 1.0e-15;
3427  if (mHh>=20. && mHh <=2000.) {
3428  SigmaTotSM_H8=ip_cs_ggtoH_8(mHh)+ip_cs_VBFtoH_8(mHh)+ip_cs_WtoWH_8(mHh)+ip_cs_ZtoZH_8(mHh)+ip_cs_pptottH_8(mHh)+ip_cs_pptobbH_8(mHh);
3429  }
3430  if (mH5>=20. && mH5 <=2000.) {
3431  SigmaTotSM_H58=ip_cs_ggtoH_8(mH5)+ip_cs_VBFtoH_8(mH5)+ip_cs_WtoWH_8(mH5)+ip_cs_ZtoZH_8(mH5)+ip_cs_pptottH_8(mH5)+ip_cs_pptobbH_8(mH5);
3432  }
3433  SigmaSumH8 = SigmaggF_H8 + SigmaVBF_H8 + SigmaVH_H8 + SigmattF_H8 + SigmabbF_H8;
3434  SigmaSumA8 = SigmaggF_A8 + SigmattF_A8 + SigmabbF_A8;
3435  SigmaSumH58 = SigmaVBF_H58 + SigmaVH_H58;
3436 
3437  SigmaggF_H13=ip_cs_ggtoH_13(mHh)*rHH_ff;
3438  SigmaggF_A13=ip_cs_ggtoA_13(mA)*rA_ff;
3439  SigmabbF_H13=ip_cs_pptobbH_13(mHh)*rHH_ff;
3440  SigmabbF_A13=ip_cs_pptobbA_13(mA)*rA_ff;
3441  SigmaVBF_H13=ip_cs_VBFtoH_13(mHh)*rHH_VV;
3442  SigmaVBF_H513=ip_cs_VBFH5_13(mH5)*cosb*cosb;
3443  SigmattF_H13=ip_cs_pptottH_13(mHh)*rHH_ff;
3444  SigmattF_A13=ip_cs_pptottA_13(mA)*rA_ff;
3445  SigmaVH_H13=(ip_cs_WtoWH_13(mHh)+ip_cs_ZtoZH_13(mHh))*rHH_VV;
3446  SigmaVH_H513=ip_cs_VHH5_13(mH5)*cosb*cosb;
3447  SigmaSumH13 = SigmaggF_H13 + SigmaVBF_H13 + SigmaVH_H13 + SigmattF_H13 + SigmabbF_H13;
3448  SigmaSumA13 = SigmaggF_A13 + SigmattF_A13 + SigmabbF_A13;
3449  SigmaSumH513 = SigmaVBF_H513 + SigmaVH_H513;
3450 
3451  SigmaHp8=ip_cs_ggtoHp_8(mA,0.0)/(tanb*tanb);
3452  SigmaHp13=ip_cs_ggtoHp_13(mA,0.0)/(tanb*tanb);
3453  SigmaHp58=(ip_cs_VBFH5p_8(mH5)+ip_cs_VBFH5m_8(mH5))*cosb*cosb;
3454  SigmaHp513=(ip_cs_VBFH5p_13(mH5)+ip_cs_VBFH5m_13(mH5))*cosb*cosb;
3455 
3456  SigmaHppHmm58=ip_cs_ppH5ppH5mm_8(mH5)*cosb*cosb;
3457  SigmaHppHmm513=ip_cs_ppH5ppH5mm_13(mH5)*cosb*cosb;
3458 // SigmaHpp58=(ip_cs_VBFH5pp_8(mH5)+ip_cs_VBFH5mm_8(mH5)+ip_cs_VHH5pp_8(mH5)+ip_cs_VHH5mm_8(mH5))*cosb*cosb;
3459 // SigmaHpp513=(ip_cs_VBFH5pp_13(mH5)+ip_cs_VBFH5mm_13(mH5)+ip_cs_VHH5pp_13(mH5)+ip_cs_VHH5mm_13(mH5))*cosb*cosb;
3460  SigmaHpp58=(ip_cs_VBFH5pp_8(mH5)+ip_cs_VBFH5mm_8(mH5))*cosb*cosb;
3461  SigmaHpp513=(ip_cs_VBFH5pp_13(mH5)+ip_cs_VBFH5mm_13(mH5))*cosb*cosb;
3462 
3463  double BrSM_Htott=ip_Br_HPtott(mHh);
3464 // double BrSM_Atott=ip_Br_HPtott(mA);
3465 
3466  double BrSM_Htocc=ip_Br_HPtocc(mHh);
3467  double BrSM_Atocc=ip_Br_HPtocc(mA);
3468 
3469  double BrSM_Htobb=ip_Br_HPtobb(mHh);
3470  double BrSM_Atobb=ip_Br_HPtobb(mA);
3471 
3472  double BrSM_Htotautau=ip_Br_HPtotautau(mHh);
3473  double BrSM_Atotautau=ip_Br_HPtotautau(mA);
3474 
3475  double BrSM_Htomumu=ip_Br_HPtomumu(mHh);
3476  double BrSM_Atomumu=ip_Br_HPtomumu(mA);
3477 
3478  double BrSM_HtoWW =ip_Br_HPtoWW(mHh);
3479  double BrSM_H5toWW =ip_Br_HPtoWW(mH5);
3480 
3481  double BrSM_HtoZZ =ip_Br_HPtoZZ(mHh);
3482  double BrSM_H5toZZ =ip_Br_HPtoZZ(mH5);
3483 
3484  GammaHtotSM=ip_GammaHPtotSM(mHh);
3485  double GammaAtotSM=ip_GammaHPtotSM(mA);
3486 
3487  //Following partial widths stem from the GMcalc manual 1412.7387
3488  //lambda^{1/2}(x,y) is equivalent to 2*KaellenFunction(1,x,y)
3489 
3490  // H3p -> f f' decays (assuming Vtb=1)
3491 
3492  double GammaHptb = HSTheta(mA-MtPole-Mb)*3.0*cosb*cosb/(4.0*M_PI*mA*vev*vev*sinb*sinb)
3493  *(mAsq*(MtPole*MtPole+Mb*Mb) - (MtPole*MtPole-Mb*Mb)*(MtPole*MtPole-Mb*Mb))
3494  *KaellenFunction(1.0,MtPole*MtPole/mAsq,Mb*Mb/mAsq);
3495 
3496  double GammaHptaunu = HSTheta(mA-Mtau)*cosb*cosb/(4.0*M_PI*mA*vev*vev*sinb*sinb)*
3497  (mAsq-Mtau*Mtau)*Mtau*Mtau*KaellenFunction(1.0,Mtau*Mtau/mAsq,0.0);
3498 
3499  // H5 -> V V decays
3500 
3501  double kW=MW*MW/mH5sq;
3502 
3503  double GammaH5WW = /*On-shell part*/
3504  HSTheta(mH5-2.0*MW)*(M_PI*Ale*Ale*vev*vev*cosb*cosb)
3505  *(1.0-4.0*kW+12.0*kW*kW)
3506  *mH5sq*mH5*KaellenFunction(1.0,kW,kW)/(24.0*MW*MW*MW*MW*sW2*sW2)
3507  /*Off-shell part*/
3508  +HSTheta(2.0*MW-mH5)*HSTheta(mH5-MW)*mH5*(3.0*Ale*Ale*cosb*cosb)/(32.0*M_PI*sW2*sW2)
3509  *OffShellFunction(kW);
3510 
3511  double GammaH5ZZ = /*On-shell part*/
3512  HSTheta(mH5-2.0*MZ)*(M_PI*Ale*Ale*vev*vev*cosb*cosb)
3513  *(1.0-4.0*MZ*MZ/mH5sq+12.0*MZ*MZ*MZ*MZ/(mH5sq*mH5sq))
3514  *mH5sq*mH5*KaellenFunction(1.0,MZ*MZ/mH5sq,MZ*MZ/mH5sq)/(12.0*MZ*MZ*MZ*MZ*sW2*sW2*cW2*cW2)
3515  /*Off-shell part*/
3516  +HSTheta(2.0*MZ-mH5)*HSTheta(mH5-MZ)*(7.0/12.0-10.0*sW2/9.0+40.0*sW2*sW2/27.0)
3517  *mH5*(3.0*Ale*Ale*cosb*cosb)/(8.0*M_PI*sW2*sW2*cW2*cW2)*OffShellFunction(MZ*MZ/mH5sq);
3518 
3519  double GammaH5pZW = HSTheta(mH5-MZ-MW)*(M_PI*Ale*Ale*vev*vev*cosb*cosb)
3520  *(1.0-2.0*MZ*MZ/mH5sq-2.0*MW*MW/mH5sq+10.0*MZ*MZ*MW*MW/(mH5sq*mH5sq)+MZ*MZ*MZ*MZ/(mH5sq*mH5sq)+MW*MW*MW*MW/(mH5sq*mH5sq))
3521  *mH5sq*mH5*KaellenFunction(1.0,MZ*MZ/mH5sq,MW*MW/mH5sq)/(8.0*MZ*MZ*MW*MW*cW2*sW2*sW2);
3522 
3523  double GammaH5ppWW = /*On-shell part*/
3524  HSTheta(mH5-2.0*MW)*(M_PI*Ale*Ale*vev*vev*cosb*cosb)
3525  *(1.0-4.0*kW+12.0*kW*kW)
3526  *mH5sq*mH5*KaellenFunction(1.0,kW,kW)/(8.0*MW*MW*MW*MW*sW2*sW2)
3527  /*Off-shell part*/
3528  +HSTheta(2.0*MW-mH5)*HSTheta(mH5-MW)*9.0*mH5*(Ale*Ale*cosb*cosb)/(32.0*M_PI*sW2*sW2)
3529  *OffShellFunction(kW);
3530 
3531  // H1 -> V H2 decays
3532  //lambda(x/y,z/y)*lambda^{1/2}(y/x,z/x) = KaellenFunction(x,y,z)^3 * 8*sqrt(x)/y^2
3533 
3534  double GammaHAZ = HSTheta(mHh-mA-MZ)*2.0*Ale*(0.25*sina*sina*cosb*cosb-2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*cosa*cosa*sinb*sinb)
3535  *KaellenFunction(mH1sq,MZ*MZ,mAsq)*KaellenFunction(mH1sq,MZ*MZ,mAsq)*KaellenFunction(mH1sq,MZ*MZ,mAsq)
3536  /(cW2*sW2*MZ*MZ);
3537 
3538  double GammaHHpW = HSTheta(mHh-mA-MW)*2.0*Ale*(0.25*sina*sina*cosb*cosb-2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*cosa*cosa*sinb*sinb)
3539  *KaellenFunction(mH1sq,MW*MW,mAsq)*KaellenFunction(mH1sq,MW*MW,mAsq)*KaellenFunction(mH1sq,MW*MW,mAsq)
3540  /(sW2*MW*MW);
3541 
3542  double GammaAhZ = HSTheta(mA-sqrt(mHl2)-MZ)*2.0*Ale*(0.25*cosa*cosa*cosb*cosb+2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*sina*sina*sinb*sinb)
3543  *KaellenFunction(mAsq,MZ*MZ,mHl2)*KaellenFunction(mAsq,MZ*MZ,mHl2)*KaellenFunction(mAsq,MZ*MZ,mHl2)
3544  /(cW2*sW2*MZ*MZ);
3545 
3546  double GammaAHZ = HSTheta(mA-mHh-MZ)*2.0*Ale*(0.25*sina*sina*cosb*cosb-2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*cosa*cosa*sinb*sinb)
3547  *KaellenFunction(mAsq,MZ*MZ,mH1sq)*KaellenFunction(mAsq,MZ*MZ,mH1sq)*KaellenFunction(mAsq,MZ*MZ,mH1sq)
3548  /(cW2*sW2*MZ*MZ);
3549 
3550  double GammaAH5Z = HSTheta(mA-mH5-MZ)*2.0*Ale*sinb*sinb
3551  *KaellenFunction(mAsq,MZ*MZ,mH5sq)*KaellenFunction(mAsq,MZ*MZ,mH5sq)*KaellenFunction(mAsq,MZ*MZ,mH5sq)
3552  /(3.0*sW2*cW2*MZ*MZ);
3553 
3554  double GammaAH5pW = HSTheta(mA-mH5-MW)*Ale*sinb*sinb
3555  *KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)
3556  /(2.0*sW2*MW*MW);
3557 
3558  double GammaHphW = HSTheta(mA-mHl-MW)*2.0*Ale*(0.25*cosa*cosa*cosb*cosb+2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*sina*sina*sinb*sinb)
3559  *KaellenFunction(mAsq,MW*MW,mHl*mHl)*KaellenFunction(mAsq,MW*MW,mHl*mHl)*KaellenFunction(mAsq,MW*MW,mHl*mHl)
3560  /(sW2*MW*MW);
3561 
3562  double GammaHpHW = HSTheta(mA-mHh-MW)*2.0*Ale*(0.25*sina*sina*cosb*cosb-2.0/sqrt(6.0)*sina*cosa*sinb*cosb+2.0/3.0*cosa*cosa*sinb*sinb)
3563  *KaellenFunction(mAsq,MW*MW,mH1sq)*KaellenFunction(mAsq,MW*MW,mH1sq)*KaellenFunction(mAsq,MW*MW,mH1sq)
3564  /(sW2*MW*MW);
3565 
3566  double GammaHpH5pZ = HSTheta(mA-mH5-MZ)*(Ale*sinb*sinb)
3567  *KaellenFunction(mAsq,MZ*MZ,mH5sq)*KaellenFunction(mAsq,MZ*MZ,mH5sq)*KaellenFunction(mAsq,MZ*MZ,mH5sq)
3568  /(2.0*MZ*MZ*sW2*cW2);
3569 
3570  double GammaHpH5W = HSTheta(mA-mH5-MW)*(Ale*sinb*sinb)
3571  *KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)
3572  /(6.0*sW2*MW*MW);
3573 
3574  double GammaHpH5ppW = HSTheta(mA-mH5-MW)*(Ale*sinb*sinb)
3575  *KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)*KaellenFunction(mAsq,MW*MW,mH5sq)
3576  /(sW2*MW*MW);
3577 
3578  double GammaH5AZ = HSTheta(mH5-mA-MZ)*(2.0*Ale*sinb*sinb)
3579  *KaellenFunction(mH5sq,MZ*MZ,mAsq)*KaellenFunction(mH5sq,MZ*MZ,mAsq)*KaellenFunction(mH5sq,MZ*MZ,mAsq)
3580  /(3.0*sW2*cW2*MZ*MZ);
3581 
3582  double GammaH5HpW = HSTheta(mH5-mA-MW)*(Ale*sinb*sinb)
3583  *KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)
3584  /(6.0*sW2*MW*MW);
3585 
3586  double GammaH5pAW = HSTheta(mH5-mA-MW)*(Ale*sinb*sinb)
3587  *KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)
3588  /(2.0*sW2*MW*MW);
3589 
3590  double GammaH5pHpZ = HSTheta(mH5-mA-MZ)*(Ale*sinb*sinb)
3591  *KaellenFunction(mH5sq,MZ*MZ,mAsq)*KaellenFunction(mH5sq,MZ*MZ,mAsq)*KaellenFunction(mH5sq,MZ*MZ,mAsq)
3592  /(2.0*sW2*cW2*MZ*MZ);
3593 
3594  double GammaH5ppHpW = HSTheta(mH5-mA-MW)*(Ale*sinb*sinb)
3595  *KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)*KaellenFunction(mH5sq,MW*MW,mAsq)
3596  /(sW2*MW*MW);
3597 
3598  // H1 -> H2 H3 decays
3599 
3600  double GammaHhh = HSTheta(mHh-2.0*sqrt(mHl2))*fabs(ghhH)*fabs(ghhH)
3601  *KaellenFunction(1.0,mHl2/mH1sq,mHl2/mH1sq)/(16.0*mHh*M_PI);
3602 
3603  double GammaHHpHm = HSTheta(mHh-2.0*mA)*fabs(gHH3H3)*fabs(gHH3H3)
3604  *KaellenFunction(1.0,mAsq/mH1sq,mAsq/mH1sq)/(8.0*mHh*M_PI);
3605 
3606  double GammaHAA = HSTheta(mHh-2.0*mA)*fabs(gHH3H3)*fabs(gHH3H3)
3607  *KaellenFunction(1.0,mAsq/mH1sq,mAsq/mH1sq)/(16.0*mHh*M_PI);
3608 
3609  double GammaHH5H5 = HSTheta(mHh-2.0*mH5)*fabs(gHH5H5)*fabs(gHH5H5)
3610  *KaellenFunction(1.0,mH5sq/mH1sq,mH5sq/mH1sq)/(16.0*mHh*M_PI);
3611 
3612  double GammaHH5pH5m = 2.0*GammaHH5H5;
3613 
3614  double GammaHH5ppH5mm = 2.0*GammaHH5H5;
3615 
3616  double GammaH5HpHm = HSTheta(mH5-2.0*mA)*fabs(gH5H3pH3m)*fabs(gH5H3pH3m)
3617  *KaellenFunction(1.0,mAsq/mH5sq,mAsq/mH5sq)/(8.0*mH5*M_PI);
3618 
3619  double GammaH5AA = HSTheta(mH5-2.0*mA)*fabs(gH3H3H5)*fabs(gH3H3H5)
3620  *KaellenFunction(1.0,mAsq/mH5sq,mAsq/mH5sq)/(16.0*mH5*M_PI);
3621 
3622  double GammaH5pHpA = HSTheta(mH5-2.0*mA)*gH3H3pH5m.abs2()
3623  *KaellenFunction(1.0,mAsq/mH5sq,mAsq/mH5sq)/(8.0*mH5*M_PI);
3624 
3625  double GammaH5ppHpHp = HSTheta(mH5-2.0*mA)*fabs(gH5ppH3mH3m)*fabs(gH5ppH3mH3m)
3626  *KaellenFunction(1.0,mAsq/mH5sq,mAsq/mH5sq)/(8.0*mH5*M_PI);
3627 
3628  GammaH1tot= (rHH_ff*(BrSM_Htott+BrSM_Htocc+BrSM_Htobb+BrSM_Htotautau+BrSM_Htomumu)
3629  +rHH_VV*(BrSM_HtoWW+BrSM_HtoZZ))*GammaHtotSM
3630  +Gamma_Hgg+Gamma_Hgaga+Gamma_HZga
3631  +GammaHAZ+GammaHHpW
3632  +GammaHhh+GammaHHpHm+GammaHAA
3633  +GammaHH5H5+GammaHH5pH5m+GammaHH5ppH5mm;
3634 
3635  GammaH3tot= rA_ff*(BrSM_Atocc+BrSM_Atobb+BrSM_Atotautau+BrSM_Atomumu)*GammaAtotSM
3636  +Gamma_Att+Gamma_Agg+Gamma_Agaga+Gamma_AZga
3637  +GammaAhZ+GammaAHZ
3638  +GammaAH5Z+GammaAH5pW;
3639 
3640  GammaH3ptot= GammaHptb+GammaHptaunu
3641  +GammaHphW+GammaHpHW
3642  +GammaHpH5pZ+GammaHpH5W+GammaHpH5ppW+1.e-20;
3643 
3644  GammaH5tot= GammaH5WW+GammaH5ZZ
3645  +Gamma_H5gg+Gamma_H5gaga+Gamma_H5Zga
3646  +GammaH5AZ+GammaH5HpW
3647  +GammaH5HpHm+GammaH5AA+1.e-20;
3648 
3649  GammaH5ptot= GammaH5pZW+GammaH5pAW+GammaH5pHpZ+GammaH5pHpA+1.e-20;
3650 
3651  GammaH5pptot= GammaH5ppWW+GammaH5ppHpW+GammaH5ppHpHp+1.e-20;
3652 
3653 // std::cout<<"Gamma_Hff = "<<rHH_ff*(BrSM_Htott+BrSM_Htocc+BrSM_Htobb+BrSM_Htotautau+BrSM_Htomumu)*GammaHtotSM<<std::endl;
3654 // std::cout<<"Gamma_HVV = "<<rHH_VV*(BrSM_HtoWW+BrSM_HtoZZ)*GammaHtotSM<<std::endl;
3655 // std::cout<<"Gamma_Hgg = "<<Gamma_Hgg<<std::endl;
3656 // std::cout<<"Gamma_Hgaga = "<<Gamma_Hgaga<<std::endl;
3657 // std::cout<<"Gamma_HZga = "<<Gamma_HZga<<std::endl;
3658 // std::cout<<"GammaHAZ = "<<GammaHAZ<<std::endl;
3659 // std::cout<<"GammaHHpW = "<<GammaHHpW<<std::endl;
3660 // std::cout<<"GammaHhh = "<<GammaHhh<<std::endl;
3661 // std::cout<<"GammaHAA = "<<GammaHAA<<std::endl;
3662 // std::cout<<"GammaHHpHm = "<<GammaHHpHm<<std::endl;
3663 // std::cout<<"GammaHH5H5 = "<<GammaHH5H5<<std::endl;
3664 // std::cout<<"GammaHH5pH5m = "<<GammaHH5pH5m<<std::endl;
3665 // std::cout<<"GammaHH5ppH5mm = "<<GammaHH5ppH5mm<<std::endl;
3666 // std::cout<<"GammaH1tot = "<<GammaH1tot<<std::endl;
3667 // std::cout<<"------------------------"<<std::endl;
3668 // std::cout<<"Gamma_Aff = "<<Gamma_Att+rA_ff*(BrSM_Atocc+BrSM_Atobb+BrSM_Atotautau+BrSM_Atomumu)*GammaAtotSM<<std::endl;
3669 // std::cout<<"Gamma_Agg = "<<Gamma_Agg<<std::endl;
3670 // std::cout<<"Gamma_Agaga = "<<Gamma_Agaga<<std::endl;
3671 // std::cout<<"Gamma_AZga = "<<Gamma_AZga<<std::endl;
3672 // std::cout<<"GammaAhZ = "<<GammaAhZ<<std::endl;
3673 // std::cout<<"GammaAHZ = "<<GammaAHZ<<std::endl;
3674 // std::cout<<"GammaAH5Z = "<<GammaAH5Z<<std::endl;
3675 // std::cout<<"GammaAH5pW = "<<GammaAH5pW<<std::endl;
3676 // std::cout<<"GammaH3tot = "<<GammaH3tot<<std::endl;
3677 // std::cout<<"------------------------"<<std::endl;
3678 // std::cout<<"GammaHptb = "<<GammaHptb<<std::endl;
3679 // std::cout<<"GammaHptaunu = "<<GammaHptaunu<<std::endl;
3680 // std::cout<<"GammaHphW = "<<GammaHphW<<std::endl;
3681 // std::cout<<"GammaHpHW = "<<GammaHpHW<<std::endl;
3682 // std::cout<<"GammaHpH5pZ = "<<GammaHpH5pZ<<std::endl;
3683 // std::cout<<"GammaHpH5W = "<<GammaHpH5W<<std::endl;
3684 // std::cout<<"GammaHpH5ppW = "<<GammaHpH5ppW<<std::endl;
3685 // std::cout<<"GammaH3ptot = "<<GammaH3ptot<<std::endl;
3686 // std::cout<<"------------------------"<<std::endl;
3687 // std::cout<<"GammaH5WW = "<<GammaH5WW<<std::endl;
3688 // std::cout<<"GammaH5ZZ = "<<GammaH5ZZ<<std::endl;
3689 // std::cout<<"Gamma_H5gg = "<<Gamma_H5gg<<std::endl;
3690 // std::cout<<"Gamma_H5gaga = "<<Gamma_H5gaga<<std::endl;
3691 // std::cout<<"Gamma_H5Zga = "<<Gamma_H5Zga<<std::endl;
3692 // std::cout<<"GammaH5AZ = "<<GammaH5AZ<<std::endl;
3693 // std::cout<<"GammaH5HpW = "<<GammaH5HpW<<std::endl;
3694 // std::cout<<"GammaH5HpHm = "<<GammaH5HpHm<<std::endl;
3695 // std::cout<<"GammaH5AA = "<<GammaH5AA<<std::endl;
3696 // std::cout<<"GammaH5tot = "<<GammaH5tot<<std::endl;
3697 // std::cout<<"------------------------"<<std::endl;
3698 // std::cout<<"GammaH5pZW = "<<GammaH5pZW<<std::endl;
3699 // std::cout<<"GammaH5pAW = "<<GammaH5pAW<<std::endl;
3700 // std::cout<<"GammaH5pHpZ = "<<GammaH5pHpZ<<std::endl;
3701 // std::cout<<"GammaH5pHpA = "<<GammaH5pHpA<<std::endl;
3702 // std::cout<<"GammaH5ptot = "<<GammaH5ptot<<std::endl;
3703 // std::cout<<"------------------------"<<std::endl;
3704 // std::cout<<"GammaH5ppWW = "<<GammaH5ppWW<<std::endl;
3705 // std::cout<<"GammaH5ppHpW = "<<GammaH5ppHpW<<std::endl;
3706 // std::cout<<"GammaH5ppHpHp = "<<GammaH5ppHpHp<<std::endl;
3707 // std::cout<<"GammaH5pptot = "<<GammaH5pptot<<std::endl;
3708 
3709  Br_Htott=BrSM_Htott*rHH_ff*GammaHtotSM/GammaH1tot;
3710  Br_Htobb=BrSM_Htobb*rHH_ff*GammaHtotSM/GammaH1tot;
3711  Br_Htotautau=BrSM_Htotautau*rHH_ff*GammaHtotSM/GammaH1tot;
3712  Br_HtoWW=BrSM_HtoWW*rHH_VV*GammaHtotSM/GammaH1tot;
3713  Br_HtoZZ=BrSM_HtoZZ*rHH_VV*GammaHtotSM/GammaH1tot;
3714  Br_Htogaga=Gamma_Hgaga/GammaH1tot;
3715  Br_HtoZga=Gamma_HZga/GammaH1tot;
3716  Br_HtoAZ=GammaHAZ/GammaH1tot;
3717  Br_HtoHpW=GammaHHpW/GammaH1tot;
3718  Br_Htohh=GammaHhh/GammaH1tot;
3719  Br_HtoAA=GammaHAA/GammaH1tot;
3720  Br_HtoHpHm=GammaHHpHm/GammaH1tot;
3721  Br_HtoH5H5=GammaHH5H5/GammaH1tot;
3722  Br_HtoH5pH5m=GammaHH5pH5m/GammaH1tot;
3723  Br_HtoH5ppH5mm=GammaHH5ppH5mm/GammaH1tot;
3724 
3725  Br_Atott=Gamma_Att/GammaH3tot;
3726  Br_Atobb=BrSM_Atobb*rA_ff*GammaAtotSM/GammaH3tot;
3727  Br_Atotautau=BrSM_Atotautau*rA_ff*GammaAtotSM/GammaH3tot;
3728  Br_Atogaga=Gamma_Agaga/GammaH3tot;
3729  Br_AtoZga=Gamma_AZga/GammaH3tot;
3730  Br_AtohZ=GammaAhZ/GammaH3tot;
3731  Br_AtoHZ=GammaAHZ/GammaH3tot;
3732  Br_AtoH5Z=GammaAH5Z/GammaH3tot;
3733  Br_AtoH5pW=GammaAH5pW/GammaH3tot;
3734 
3735  Br_Hptotaunu=GammaHptaunu/GammaH3ptot;
3736  Br_Hptotb=GammaHptb/GammaH3ptot;
3737  Br_HptohW=GammaHphW/GammaH3ptot;
3738  Br_HptoHW=GammaHpHW/GammaH3ptot;
3739  Br_HptoH5pZ=GammaHpH5pZ/GammaH3ptot;
3740  Br_HptoH5W=GammaHpH5W/GammaH3ptot;
3741  Br_HptoH5ppW=GammaHpH5ppW/GammaH3ptot;
3742 
3743  Br_H5toWW=GammaH5WW/GammaH5tot;
3744  Br_H5toZZ=GammaH5ZZ/GammaH5tot;
3745  Br_H5togaga=Gamma_H5gaga/GammaH5tot;
3746  Br_H5toZga=Gamma_H5Zga/GammaH5tot;
3747  Br_H5toAZ=GammaH5AZ/GammaH5tot;
3748  Br_H5toHpW=GammaH5HpW/GammaH5tot;
3749  Br_H5toHpHm=GammaH5HpHm/GammaH5tot;
3750  Br_H5toAA=GammaH5AA/GammaH5tot;
3751  BrRatioVV5=(GammaH5WW+GammaH5ZZ)/(GammaH5tot*(BrSM_H5toWW+BrSM_H5toZZ));
3752 
3753  Br_H5ptoWZ=GammaH5pZW/GammaH5ptot;
3754  Br_H5ptoAW=GammaH5pAW/GammaH5ptot;
3755  Br_H5ptoHpZ=GammaH5pHpZ/GammaH5ptot;
3756  Br_H5ptoHpA=GammaH5pHpA/GammaH5ptot;
3757 
3758  Br_H5pptoWW=GammaH5ppWW/GammaH5pptot;
3759  Br_H5pptoHpW=GammaH5ppHpW/GammaH5pptot;
3760  Br_H5pptoHpHp=GammaH5ppHpHp/GammaH5pptot;
3761 
3762 }
3763 
3764 void GMcache::computeDirectSearchQuantities()
3765 {
3766  computeOtherHiggsProperties();
3767  double mHh=sqrt(mH1sq);
3768  double mA=sqrt(mAsq);
3769  double mH5=sqrt(mH5sq);
3770  double Br_Ztoee=0.03363; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3771  double Br_Ztomumu=0.03366; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3772 // double Br_Ztotautau=0.0337; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3773 // double Br_Ztoinv=0.2; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3774  double Br_Wtoenu=0.1071; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3775  double Br_Wtomunu=0.1063; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3776 // double Br_Wtotaunu=0.1138; //C. Patrignani et al.(Particle Data Group), Chin. Phys. C, 40, 100001 (2016)
3777 
3778  tt_H_tt_TH13=SigmattF_H13*Br_Htott;
3779 // std::cout<<"tt_H_tt_TH13 = "<<tt_H_tt_TH13<<std::endl;
3780  bb_H_tt_TH13=SigmabbF_H13*Br_Htott;
3781 // std::cout<<"bb_H_tt_TH13 = "<<bb_H_tt_TH13<<std::endl;
3782  tt_A_tt_TH13=SigmattF_A13*Br_Atott;
3783 // std::cout<<"tt_A_tt_TH13 = "<<tt_A_tt_TH13<<std::endl;
3784  bb_A_tt_TH13=SigmabbF_A13*Br_Atott;
3785 // std::cout<<"bb_A_tt_TH13 = "<<bb_A_tt_TH13<<std::endl;
3786  bb_H_bb_TH8=SigmabbF_H8*Br_Htobb;
3787 // std::cout<<"bb_H_bb_TH8 = "<<bb_H_bb_TH8<<std::endl;
3788  gg_H_bb_TH8=SigmaggF_H8*Br_Htobb;
3789 // std::cout<<"gg_H_bb_TH8 = "<<gg_H_bb_TH8<<std::endl;
3790  pp_H_bb_TH13=SigmaSumH13*Br_Htobb;
3791 // std::cout<<"pp_H_bb_TH13 = "<<pp_H_bb_TH13<<std::endl;
3792  bb_H_bb_TH13=SigmabbF_H13*Br_Htobb;
3793 // std::cout<<"bb_H_bb_TH13 = "<<bb_H_bb_TH13<<std::endl;
3794  bb_A_bb_TH8=SigmabbF_A8*Br_Atobb;
3795 // std::cout<<"bb_A_bb_TH8 = "<<bb_A_bb_TH8<<std::endl;
3796  gg_A_bb_TH8=SigmaggF_A8*Br_Atobb;
3797 // std::cout<<"gg_A_bb_TH8 = "<<gg_A_bb_TH8<<std::endl;
3798  pp_A_bb_TH13=SigmaSumA13*Br_Atobb;
3799 // std::cout<<"pp_A_bb_TH13 = "<<pp_A_bb_TH13<<std::endl;
3800  bb_A_bb_TH13=SigmabbF_A13*Br_Atobb;
3801 // std::cout<<"bb_A_bb_TH13 = "<<bb_A_bb_TH13<<std::endl;
3802  gg_H_tautau_TH8=SigmaggF_H8*Br_Htotautau;
3803 // std::cout<<"gg_H_tautau_TH8 = "<<gg_H_tautau_TH8<<std::endl;
3804  bb_H_tautau_TH8=SigmabbF_H8*Br_Htotautau;
3805 // std::cout<<"bb_H_tautau_TH8 = "<<bb_H_tautau_TH8<<std::endl;
3806  gg_H_tautau_TH13=SigmaggF_H13*Br_Htotautau;
3807 // std::cout<<"gg_H_tautau_TH13 = "<<gg_H_tautau_TH13<<std::endl;
3808  bb_H_tautau_TH13=SigmabbF_H13*Br_Htotautau;
3809 // std::cout<<"bb_H_tautau_TH13 = "<<bb_H_tautau_TH13<<std::endl;
3810  gg_A_tautau_TH8=SigmaggF_A8*Br_Atotautau;
3811 // std::cout<<"gg_A_tautau_TH8 = "<<gg_A_tautau_TH8<<std::endl;
3812  bb_A_tautau_TH8=SigmabbF_A8*Br_Atotautau;
3813 // std::cout<<"bb_A_tautau_TH8 = "<<bb_A_tautau_TH8<<std::endl;
3814  gg_A_tautau_TH13=SigmaggF_A13*Br_Atotautau;
3815 // std::cout<<"gg_A_tautau_TH13 = "<<gg_A_tautau_TH13<<std::endl;
3816  bb_A_tautau_TH13=SigmabbF_A13*Br_Atotautau;
3817 // std::cout<<"bb_A_tautau_TH13 = "<<bb_A_tautau_TH13<<std::endl;
3818  gg_H_gaga_TH8=SigmaggF_H8*Br_Htogaga;
3819 // std::cout<<"gg_H_gaga_TH8 = "<<gg_H_gaga_TH8<<std::endl;
3820  pp_H_gaga_TH13=SigmaSumH13*Br_Atogaga;
3821 // std::cout<<"pp_H_gaga_TH13 = "<<pp_H_gaga_TH13<<std::endl;
3822  gg_H_gaga_TH13=SigmaggF_H13*Br_Htogaga;
3823 // std::cout<<"gg_H_gaga_TH13 = "<<gg_H_gaga_TH13<<std::endl;
3824  gg_A_gaga_TH8=SigmaggF_A8*Br_Atogaga;
3825 // std::cout<<"gg_A_gaga_TH8 = "<<gg_A_gaga_TH8<<std::endl;
3826  pp_A_gaga_TH13=SigmaSumA13*Br_Atogaga;
3827 // std::cout<<"pp_A_gaga_TH13 = "<<pp_A_gaga_TH13<<std::endl;
3828  gg_A_gaga_TH13=SigmaggF_A13*Br_Atogaga;
3829 // std::cout<<"gg_A_gaga_TH13 = "<<gg_A_gaga_TH13<<std::endl;
3830  pp_H5_gaga_TH13=SigmaSumH513*Br_H5togaga;
3831 // std::cout<<"pp_H5_gaga_TH13 = "<<pp_H5_gaga_TH13<<std::endl;
3832  pp_H_Zga_llga_TH8=SigmaSumH8*Br_HtoZga*(Br_Ztoee+Br_Ztomumu);
3833 // std::cout<<"pp_H_Zga_llga_TH8 = "<<pp_H_Zga_llga_TH8<<std::endl;
3834  gg_H_Zga_TH13=SigmaggF_H13*Br_HtoZga;
3835 // std::cout<<"gg_H_Zga_TH13 = "<<gg_H_Zga_TH13<<std::endl;
3836  pp_A_Zga_llga_TH8=SigmaSumA8*Br_AtoZga*(Br_Ztoee+Br_Ztomumu);
3837 // std::cout<<"pp_A_Zga_llga_TH8 = "<<pp_A_Zga_llga_TH8<<std::endl;
3838  gg_A_Zga_TH13=SigmaggF_A13*Br_AtoZga;
3839 // std::cout<<"gg_A_Zga_TH13 = "<<gg_A_Zga_TH13<<std::endl;
3840  pp_H5_Zga_llga_TH8=SigmaSumH58*Br_H5toZga*(Br_Ztoee+Br_Ztomumu);
3841 // std::cout<<"pp_H5_Zga_llga_TH8 = "<<pp_H5_Zga_llga_TH8<<std::endl;
3842  gg_H_ZZ_TH8=SigmaggF_H8*Br_HtoZZ;
3843 // std::cout<<"gg_H_ZZ_TH8 = "<<gg_H_ZZ_TH8<<std::endl;
3844  VV_H_ZZ_TH8=SigmaVBF_H8*Br_HtoZZ;
3845 // std::cout<<"VV_H_ZZ_TH8 = "<<VV_H_ZZ_TH8<<std::endl;
3846  gg_H_ZZ_TH13=SigmaggF_H13*Br_HtoZZ;
3847 // std::cout<<"gg_H_ZZ_TH13 = "<<gg_H_ZZ_TH13<<std::endl;
3848  VV_H_ZZ_TH13=SigmaVBF_H13*Br_HtoZZ;
3849 // std::cout<<"VV_H_ZZ_TH13 = "<<VV_H_ZZ_TH13<<std::endl;
3850  pp_H_ZZ_TH13=SigmaSumH13*Br_HtoZZ;
3851 // std::cout<<"pp_H_ZZ_TH13 = "<<pp_H_ZZ_TH13<<std::endl;
3852  VV_H5_ZZ_TH8=SigmaVBF_H58*Br_H5toZZ;
3853 // std::cout<<"VV_H5_ZZ_TH8 = "<<VV_H5_ZZ_TH8<<std::endl;
3854  VV_H5_ZZ_TH13=SigmaVBF_H513*Br_H5toZZ;
3855 // std::cout<<"VV_H5_ZZ_TH13 = "<<VV_H5_ZZ_TH13<<std::endl;
3856  pp_H5_ZZ_TH13=SigmaSumH513*Br_H5toZZ;
3857 // std::cout<<"pp_H5_ZZ_TH13 = "<<pp_H5_ZZ_TH13<<std::endl;
3858  gg_H_WW_TH8=SigmaggF_H8*Br_HtoWW;
3859 // std::cout<<"gg_H_WW_TH8 = "<<gg_H_WW_TH8<<std::endl;
3860  VV_H_WW_TH8=SigmaVBF_H8*Br_HtoWW;
3861 // std::cout<<"VV_H_WW_TH8 = "<<VV_H_WW_TH8<<std::endl;
3862  gg_H_WW_TH13=SigmaggF_H13*Br_HtoWW;
3863 // std::cout<<"gg_H_WW_TH13 = "<<gg_H_WW_TH13<<std::endl;
3864  VV_H_WW_TH13=SigmaVBF_H13*Br_HtoWW;
3865 // std::cout<<"VV_H_WW_TH13 = "<<VV_H_WW_TH13<<std::endl;
3866  ggVV_H_WW_lnulnu_TH13=(SigmaggF_H13+SigmaVBF_H13)*Br_HtoWW*(Br_Wtoenu+Br_Wtomunu)*(Br_Wtoenu+Br_Wtomunu);
3867 // std::cout<<"ggVV_H_WW_lnulnu_TH13 = "<<ggVV_H_WW_lnulnu_TH13<<std::endl;
3868  pp_H_WW_TH13=SigmaSumH13*Br_HtoWW;
3869 // std::cout<<"pp_H_WW_TH13 = "<<pp_H_WW_TH13<<std::endl;
3870  VV_H5_WW_TH8=SigmaVBF_H58*Br_H5toWW;
3871 // std::cout<<"VV_H5_WW_TH8 = "<<VV_H5_WW_TH8<<std::endl;
3872  VV_H5_WW_TH13=SigmaVBF_H513*Br_H5toWW;
3873 // std::cout<<"VV_H5_WW_TH13 = "<<VV_H5_WW_TH13<<std::endl;
3874  ggVV_H5_WW_lnulnu_TH13=SigmaVBF_H513*Br_H5toWW*(Br_Wtoenu+Br_Wtomunu)*(Br_Wtoenu+Br_Wtomunu);
3875 // std::cout<<"ggVV_H5_WW_lnulnu_TH13 = "<<ggVV_H5_WW_lnulnu_TH13<<std::endl;
3876  pp_H5_WW_TH13=SigmaSumH513*Br_H5toWW;
3877 // std::cout<<"pp_H5_WW_TH13 = "<<pp_H5_WW_TH13<<std::endl;
3878  pp_H_VV_TH8=SigmaSumH8*(Br_HtoZZ+Br_HtoWW);
3879 // std::cout<<"pp_H_VV_TH8 = "<<pp_H_VV_TH8<<std::endl;
3880  mu_pp_H_VV_TH8=SigmaSumH8/SigmaTotSM_H8*rHH_VV*GammaHtotSM/GammaH1tot;
3881 // std::cout<<"mu_pp_H_VV_TH8 = "<<mu_pp_H_VV_TH8<<std::endl;
3882  pp_H_VV_TH13=SigmaSumH13*(Br_HtoZZ+Br_HtoWW);
3883 // std::cout<<"pp_H_VV_TH13 = "<<pp_H_VV_TH13<<std::endl;
3884  pp_H5_VV_TH8=SigmaSumH58*(Br_H5toZZ+Br_H5toWW);
3885 // std::cout<<"pp_H5_VV_TH8 = "<<pp_H5_VV_TH8<<std::endl;
3886  mu_pp_H5_VV_TH8=SigmaSumH58/SigmaTotSM_H58*BrRatioVV5;
3887 // std::cout<<"mu_pp_H5_VV_TH8 = "<<mu_pp_H5_VV_TH8<<std::endl;
3888  pp_H5_VV_TH13=SigmaSumH513*(Br_H5toZZ+Br_H5toWW);
3889 // std::cout<<"pp_H5_VV_TH13 = "<<pp_H5_VV_TH13<<std::endl;
3890  gg_H_hh_TH8=SigmaggF_H8*Br_Htohh;
3891 // std::cout<<"gg_H_hh_TH8 = "<<gg_H_hh_TH8<<std::endl;
3892  pp_H_hh_bbbb_TH8=SigmaSumH8*Br_Htohh*GM_Br_h_bb*GM_Br_h_bb;
3893 // std::cout<<"pp_H_hh_bbbb_TH8 = "<<pp_H_hh_bbbb_TH8<<std::endl;
3894  pp_H_hh_gagabb_TH8=SigmaSumH8*Br_Htohh*GM_Br_h_gaga*GM_Br_h_bb;
3895 // std::cout<<"pp_H_hh_gagabb_TH8 = "<<pp_H_hh_gagabb_TH8<<std::endl;
3896  gg_H_hh_bbtautau_TH8=SigmaggF_H8*Br_Htohh*GM_Br_h_bb*GM_Br_h_tautau;
3897 // std::cout<<"gg_H_hh_bbtautau_TH8 = "<<gg_H_hh_bbtautau_TH8<<std::endl;
3898  pp_H_hh_TH8=SigmaSumH8*Br_Htohh;
3899 // std::cout<<"pp_H_hh_TH8 = "<<pp_H_hh_TH8<<std::endl;
3900 // pp_H5_hh_bbbb_TH8=SigmaSumH58*Br_H5tohh*GM_Br_h_bb*GM_Br_h_bb;
3901 // pp_H5_hh_gagabb_TH8=SigmaSumH58*Br_H5tohh*GM_Br_h_gaga*GM_Br_h_bb;
3902 // pp_H5_hh_TH8=SigmaSumH58*Br_H5tohh;
3903  pp_H_hh_bbbb_TH13=SigmaSumH13*Br_Htohh*GM_Br_h_bb*GM_Br_h_bb;
3904 // std::cout<<"pp_H_hh_bbbb_TH13 = "<<pp_H_hh_bbbb_TH13<<std::endl;
3905  gg_H_hh_bbbb_TH13=SigmaggF_H13*Br_Htohh*GM_Br_h_bb*GM_Br_h_bb;
3906 // std::cout<<"gg_H_hh_bbbb_TH13 = "<<gg_H_hh_bbbb_TH13<<std::endl;
3907  pp_H_hh_TH13=SigmaSumH13*Br_Htohh;
3908 // std::cout<<"pp_H_hh_TH13 = "<<pp_H_hh_TH13<<std::endl;
3909  pp_H_hh_gagabb_TH13=SigmaSumH13*Br_Htohh*GM_Br_h_gaga*GM_Br_h_bb;
3910 // std::cout<<"pp_H_hh_gagabb_TH13 = "<<pp_H_hh_gagabb_TH13<<std::endl;
3911  pp_H_hh_bbtautau_TH13=SigmaSumH13*Br_Htohh*GM_Br_h_bb*GM_Br_h_tautau;
3912 // std::cout<<"pp_H_hh_bbtautau_TH13 = "<<pp_H_hh_bbtautau_TH13<<std::endl;
3913  pp_H_hh_bblnulnu_TH13=SigmaSumH13*Br_Htohh*5.77e-1*2.15e-1*(Br_Wtoenu+Br_Wtomunu)*(Br_Wtoenu+Br_Wtomunu)*2.0;/*SM BR assumed in the CMS analysis!*/
3914 // std::cout<<"pp_H_hh_bblnulnu_TH13 = "<<pp_H_hh_bblnulnu_TH13<<std::endl;
3915  gg_H_hh_gagaWW_TH13=SigmaggF_H13*Br_Htohh*GM_Br_h_gaga*GM_Br_h_WW;
3916  gg_H_hh_TH13=SigmaggF_H13*Br_Htohh;
3917 // std::cout<<"gg_H_hh_TH13 = "<<gg_H_hh_TH13<<std::endl;
3918 // pp_H5_hh_bbbb_TH13=SigmaSumH513*Br_H5tohh*GM_Br_h_bb*GM_Br_h_bb;
3919 // pp_H5_hh_TH13=SigmaSumH513*Br_H5tohh;
3920 // pp_H5_hh_gagabb_TH13=SigmaSumH513*Br_H5tohh*GM_Br_h_gaga*GM_Br_h_bb;
3921 // pp_H5_hh_bbtautau_TH13=SigmaSumH513*Br_H5tohh*GM_Br_h_bb*GM_Br_h_tautau;
3922 // pp_H5_hh_bblnulnu_TH13=SigmaSumH513*Br_H5tohh*5.77e-1*2.15e-1*(Br_Wtoenu+Br_Wtomunu)*(Br_Wtoenu+Br_Wtomunu)*2.0;/*SM BR assumed in the CMS analysis!*/
3923  gg_A_hZ_bbZ_TH8=SigmaggF_A8*Br_AtohZ*GM_Br_h_bb;
3924 // std::cout<<"gg_A_hZ_bbZ_TH8 = "<<gg_A_hZ_bbZ_TH8<<std::endl;
3925  gg_A_hZ_bbll_TH8=SigmaggF_A8*Br_AtohZ*GM_Br_h_bb*(Br_Ztoee+Br_Ztomumu);
3926 // std::cout<<"gg_A_hZ_bbll_TH8 = "<<gg_A_hZ_bbll_TH8<<std::endl;
3927  gg_A_hZ_tautauZ_TH8=SigmaggF_A8*Br_AtohZ*GM_Br_h_tautau;
3928 // std::cout<<"gg_A_hZ_tautauZ_TH8 = "<<gg_A_hZ_tautauZ_TH8<<std::endl;
3929  gg_A_hZ_tautaull_TH8=SigmaggF_A8*Br_AtohZ*GM_Br_h_tautau*(Br_Ztoee+Br_Ztomumu);
3930 // std::cout<<"gg_A_hZ_tautaull_TH8 = "<<gg_A_hZ_tautaull_TH8<<std::endl;
3931  gg_A_hZ_bbZ_TH13=SigmaggF_A13*Br_AtohZ*GM_Br_h_bb;
3932 // std::cout<<"gg_A_hZ_bbZ_TH13 = "<<gg_A_hZ_bbZ_TH13<<std::endl;
3933  bb_A_hZ_bbZ_TH13=SigmabbF_A13*Br_AtohZ*GM_Br_h_bb;
3934 // std::cout<<"bb_A_hZ_bbZ_TH13 = "<<bb_A_hZ_bbZ_TH13<<std::endl;
3935  pp_A_HZ_bbll_TH8=SigmaSumA8*Br_AtoHZ*Br_Htobb*(Br_Ztoee+Br_Ztomumu);
3936 // std::cout<<"pp_A_HZ_bbll_TH8 = "<<pp_A_HZ_bbll_TH8<<std::endl;
3937  pp_A_H5Z_bbll_TH8=0.0;
3938  gg_A_HZ_bbZ_TH13=SigmaggF_A13*Br_AtoHZ*Br_Htobb;
3939  bb_A_HZ_bbZ_TH13=SigmabbF_A13*Br_AtoHZ*Br_Htobb;
3940  pp_H_AZ_bbll_TH8=SigmaSumH8*Br_HtoAZ*Br_Atobb*(Br_Ztoee+Br_Ztomumu);
3941 // std::cout<<"pp_H_AZ_bbll_TH8 = "<<pp_H_AZ_bbll_TH8<<std::endl;
3942  pp_H5_AZ_bbll_TH8=SigmaSumH58*Br_H5toAZ*Br_Atobb*(Br_Ztoee+Br_Ztomumu);
3943 // std::cout<<"pp_H5_AZ_bbll_TH8 = "<<pp_H5_AZ_bbll_TH8<<std::endl;
3944 
3945  pp_Hpm_taunu_TH8=2.0*SigmaHp8*Br_Hptotaunu;
3946 // std::cout<<"pp_Hpm_taunu_TH8 = "<<pp_Hpm_taunu_TH8<<std::endl;
3947  pp_Hp_taunu_TH8=SigmaHp8*Br_Hptotaunu;
3948 // std::cout<<"pp_Hp_taunu_TH8 = "<<pp_Hp_taunu_TH8<<std::endl;
3949  pp_Hpm_taunu_TH13=2.0*SigmaHp8*Br_Hptotaunu;
3950 // std::cout<<"pp_Hpm_taunu_TH13 = "<<pp_Hpm_taunu_TH13<<std::endl;
3951  pp_Hpm_tb_TH8=2.0*SigmaHp8*Br_Hptotb;
3952 // std::cout<<"pp_Hpm_tb_TH8 = "<<pp_Hpm_tb_TH8<<std::endl;
3953  pp_Hp_tb_TH8=SigmaHp8*Br_Hptotb;
3954 // std::cout<<"pp_Hp_tb_TH8 = "<<pp_Hp_tb_TH8<<std::endl;
3955  pp_Hpm_tb_TH13=2.0*SigmaHp13*Br_Hptotb;
3956 // std::cout<<"pp_Hpm_tb_TH13 = "<<pp_Hpm_tb_TH13<<std::endl;
3957  WZ_H5pm_WZ_TH8=SigmaHp58*Br_H5ptoWZ;
3958 // std::cout<<"WZ_H5pm_WZ_TH8 = "<<WZ_H5pm_WZ_TH8<<std::endl;
3959  WZ_H5pm_WZ_TH13=SigmaHp513*Br_H5ptoWZ;
3960 // std::cout<<"WZ_H5pm_WZ_TH13 = "<<WZ_H5pm_WZ_TH13<<std::endl;
3961 
3962  pp_H5ppmmH5mmpp_TH8=SigmaHppHmm58;
3963 // std::cout<<"pp_H5ppmmH5mmpp_TH8 = "<<pp_H5ppmmH5mmpp_TH8<<std::endl;
3964  pp_H5ppmmH5mmpp_TH13=SigmaHppHmm513;
3965 // std::cout<<"pp_H5ppmmH5mmpp_TH13 = "<<pp_H5ppmmH5mmpp_TH13<<std::endl;
3966  pp_H5ppmmH5mmpp_WWWW_TH13=SigmaHppHmm513*Br_H5pptoWW*Br_H5pptoWW;
3967 // std::cout<<"pp_H5ppmmH5mmpp_WWWW_TH13 = "<<pp_H5ppmmH5mmpp_WWWW_TH13<<std::endl;
3968  VV_H5ppmm_WW_TH8=SigmaHpp58*Br_H5pptoWW;
3969 // std::cout<<"VV_H5ppmm_WW_TH8 = "<<VV_H5ppmm_WW_TH8<<std::endl;
3970  VV_H5ppmm_WW_TH13=SigmaHpp513*Br_H5pptoWW;
3971 // std::cout<<"VV_H5ppmm_WW_TH13 = "<<VV_H5ppmm_WW_TH13<<std::endl;
3972 
3973  THoEX_tt_H_tt_ATLAS13=0.0;
3974  THoEX_bb_H_tt_ATLAS13=0.0;
3975  THoEX_tt_A_tt_ATLAS13=0.0;
3976  THoEX_bb_A_tt_ATLAS13=0.0;
3977  THoEX_bb_H_bb_CMS8=0.0;
3978  THoEX_gg_H_bb_CMS8=0.0;
3979  THoEX_pp_H_bb_CMS13=0.0;
3980  THoEX_bb_H_bb_CMS13=0.0;
3981  THoEX_bb_A_bb_CMS8=0.0;
3982  THoEX_gg_A_bb_CMS8=0.0;
3983  THoEX_pp_A_bb_CMS13=0.0;
3984  THoEX_bb_A_bb_CMS13=0.0;
3985  THoEX_gg_H_tautau_ATLAS8=0.0;
3986  THoEX_gg_H_tautau_CMS8=0.0;
3987  THoEX_bb_H_tautau_ATLAS8=0.0;
3988  THoEX_bb_H_tautau_CMS8=0.0;
3989  THoEX_gg_H_tautau_ATLAS13=0.0;
3990  THoEX_gg_H_tautau_CMS13=0.0;
3991  THoEX_bb_H_tautau_ATLAS13=0.0;
3992  THoEX_bb_H_tautau_CMS13=0.0;
3993  THoEX_gg_A_tautau_ATLAS8=0.0;
3994  THoEX_gg_A_tautau_CMS8=0.0;
3995  THoEX_bb_A_tautau_ATLAS8=0.0;
3996  THoEX_bb_A_tautau_CMS8=0.0;
3997  THoEX_gg_A_tautau_ATLAS13=0.0;
3998  THoEX_gg_A_tautau_CMS13=0.0;
3999  THoEX_bb_A_tautau_ATLAS13=0.0;
4000  THoEX_bb_A_tautau_CMS13=0.0;
4001  THoEX_gg_H_gaga_ATLAS8=0.0;
4002  THoEX_pp_H_gaga_ATLAS13=0.0;
4003  THoEX_gg_H_gaga_CMS13=0.0;
4004  THoEX_gg_A_gaga_ATLAS8=0.0;
4005  THoEX_pp_A_gaga_ATLAS13=0.0;
4006  THoEX_gg_A_gaga_CMS13=0.0;
4007  THoEX_pp_H5_gaga_ATLAS13=0.0;
4008  THoEX_pp_H_Zga_llga_ATLAS8=0.0;
4009  THoEX_pp_H_Zga_llga_CMS8=0.0;
4010  THoEX_gg_H_Zga_llga_ATLAS13=0.0;
4011  THoEX_gg_H_Zga_qqga_ATLAS13=0.0;
4012  THoEX_gg_H_Zga_CMS13=0.0;
4013  THoEX_pp_A_Zga_llga_ATLAS8=0.0;
4014  THoEX_pp_A_Zga_llga_CMS8=0.0;
4015  THoEX_gg_A_Zga_llga_ATLAS13=0.0;
4016  THoEX_gg_A_Zga_qqga_ATLAS13=0.0;
4017  THoEX_gg_A_Zga_CMS13=0.0;
4018  THoEX_pp_H5_Zga_llga_ATLAS8=0.0;
4019  THoEX_pp_H5_Zga_llga_CMS8=0.0;
4020  THoEX_gg_H_ZZ_ATLAS8=0.0;
4021  THoEX_VV_H_ZZ_ATLAS8=0.0;
4022  THoEX_gg_H_ZZ_llllnunu_ATLAS13=0.0;
4023  THoEX_VV_H_ZZ_llllnunu_ATLAS13=0.0;
4024  THoEX_gg_H_ZZ_qqllnunu_ATLAS13=0.0;
4025  THoEX_VV_H_ZZ_qqllnunu_ATLAS13=0.0;
4026  THoEX_pp_H_ZZ_llqqnunull_CMS13=0.0;
4027  THoEX_VV_H_ZZ_llqqnunull_CMS13=0.0;
4028  THoEX_pp_H_ZZ_qqnunu_CMS13=0.0;
4029  THoEX_VV_H5_ZZ_ATLAS8=0.0;
4030  THoEX_VV_H5_ZZ_llllnunu_ATLAS13=0.0;
4031  THoEX_VV_H5_ZZ_qqllnunu_ATLAS13=0.0;
4032  THoEX_pp_H5_ZZ_llqqnunull_CMS13=0.0;
4033  THoEX_VV_H5_ZZ_llqqnunull_CMS13=0.0;
4034  THoEX_pp_H5_ZZ_qqnunu_CMS13=0.0;
4035  THoEX_gg_H_WW_ATLAS8=0.0;
4036  THoEX_VV_H_WW_ATLAS8=0.0;
4037  THoEX_gg_H_WW_enumunu_ATLAS13=0.0;
4038  THoEX_VV_H_WW_enumunu_ATLAS13=0.0;
4039  THoEX_gg_H_WW_lnuqq_ATLAS13=0.0;
4040  THoEX_VV_H_WW_lnuqq_ATLAS13=0.0;
4041  THoEX_ggVV_H_WW_lnulnu_CMS13=0.0;
4042  THoEX_pp_H_WW_lnuqq_CMS13=0.0;
4043  THoEX_VV_H5_WW_ATLAS8=0.0;
4044  THoEX_VV_H5_WW_enumunu_ATLAS13=0.0;
4045  THoEX_VV_H5_WW_lnuqq_ATLAS13=0.0;
4046  THoEX_ggVV_H5_WW_lnulnu_CMS13=0.0;
4047  THoEX_pp_H5_WW_lnuqq_CMS13=0.0;
4048  THoEX_mu_pp_H_VV_CMS8=0.0;
4049  THoEX_pp_H_VV_qqqq_ATLAS13=0.0;
4050  THoEX_mu_pp_H5_VV_CMS8=0.0;
4051  THoEX_pp_H5_VV_qqqq_ATLAS13=0.0;
4052  THoEX_gg_H_hh_ATLAS8=0.0;
4053  THoEX_pp_H_hh_bbbb_CMS8=0.0;
4054  THoEX_pp_H_hh_gagabb_CMS8=0.0;
4055  THoEX_gg_H_hh_bbtautau_CMS8=0.0;
4056  THoEX_pp_H_hh_bbtautau_CMS8=0.0;
4057  THoEX_pp_H_hh_bbbb_ATLAS13=0.0;
4058  THoEX_pp_H_hh_bbbb_1_CMS13=0.0;
4059  THoEX_pp_H_hh_bbbb_2_CMS13=0.0;
4060  THoEX_gg_H_hh_bbbb_CMS13=0.0;
4061  THoEX_pp_H_hh_gagabb_ATLAS13=0.0;
4062  THoEX_pp_H_hh_gagabb_CMS13=0.0;
4063  THoEX_pp_H_hh_bbtautau_ATLAS13=0.0;
4064  THoEX_pp_H_hh_bbtautau_1_CMS13=0.0;
4065  THoEX_pp_H_hh_bbtautau_2_CMS13=0.0;
4066  THoEX_pp_H_hh_bblnulnu_CMS13=0.0;
4067  THoEX_gg_H_hh_gagaWW_ATLAS13=0.0;
4068  THoEX_pp_H5_hh_bbbb_CMS8=0.0;
4069  THoEX_pp_H5_hh_gagabb_CMS8=0.0;
4070  THoEX_pp_H5_hh_bbtautau_CMS8=0.0;
4071  THoEX_pp_H5_hh_bbbb_ATLAS13=0.0;
4072  THoEX_pp_H5_hh_bbbb_CMS13=0.0;
4073  THoEX_pp_H5_hh_gagabb_ATLAS13=0.0;
4074  THoEX_pp_H5_hh_gagabb_CMS13=0.0;
4075  THoEX_pp_H5_hh_bbtautau_CMS13=0.0;
4076  THoEX_pp_H5_hh_bblnulnu_CMS13=0.0;
4077  THoEX_gg_A_hZ_bbZ_ATLAS8=0.0;
4078  THoEX_gg_A_hZ_bbll_CMS8=0.0;
4079  THoEX_gg_A_hZ_tautauZ_ATLAS8=0.0;
4080  THoEX_gg_A_hZ_tautaull_CMS8=0.0;
4081  THoEX_gg_A_hZ_bbZ_ATLAS13=0.0;
4082  THoEX_bb_A_hZ_bbZ_ATLAS13=0.0;
4083  THoEX_gg_A_hZ_bbZ_1_CMS13=0.0;
4084  THoEX_bb_A_hZ_bbZ_1_CMS13=0.0;
4085  THoEX_gg_A_hZ_bbZ_2_CMS13=0.0;
4086  THoEX_bb_A_hZ_bbZ_2_CMS13=0.0;
4087  THoEX_pp_A_HZ_bbll_CMS8=0.0;
4088  THoEX_pp_A_H5Z_bbll_CMS8=0.0;
4089  THoEX_gg_A_HZ_bbll_ATLAS13=0.0;
4090  THoEX_bb_A_HZ_bbll_ATLAS13=0.0;
4091  THoEX_pp_H_AZ_bbll_CMS8=0.0;
4092  THoEX_pp_H5_AZ_bbll_CMS8=0.0;
4093  THoEX_pp_Hpm_taunu_ATLAS8=0.0;
4094  THoEX_pp_Hp_taunu_CMS8=0.0;
4095  THoEX_pp_Hpm_taunu_ATLAS13=0.0;
4096  THoEX_pp_Hpm_taunu_CMS13=0.0;
4097  THoEX_pp_Hpm_tb_ATLAS8=0.0;
4098  THoEX_pp_Hp_tb_CMS8=0.0;
4099  THoEX_pp_Hpm_tb_ATLAS13=0.0;
4100  THoEX_WZ_H5pm_WZ_qqll_ATLAS8=0.0;
4101  THoEX_WZ_H5pm_WZ_lnull_ATLAS13=0.0;
4102  THoEX_WZ_H5pm_WZ_lnull_1_CMS13=0.0;
4103  THoEX_WZ_H5pm_WZ_lnull_2_CMS13=0.0;
4104  THoEX_pp_H5ppmmH5mmpp_eeee_ATLAS8=0.0;
4105  THoEX_pp_H5ppmmH5mmpp_emuemu_ATLAS8=0.0;
4106  THoEX_pp_H5ppmmH5mmpp_mumumumu_ATLAS8=0.0;
4107  THoEX_pp_H5ppmmH5mmpp_llll_ATLAS13=0.0;
4108  THoEX_pp_H5ppmmH5mmpp_WWWW_ATLAS13=0.0;
4109  THoEX_VV_H5ppmm_WW_jjll_CMS8=0.0;
4110  THoEX_VV_H5ppmm_WW_jjll_CMS13=0.0;
4111 
4112 // if(mHh>=65.0 && mHh<90.0)
4113 // {
4114 // }
4115 // else if(mHh>=90.0 && mHh<100.0)
4116 // {
4117 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4118 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4119 // }
4120 // else if(mHh>=100.0 && mHh<130.0)
4121 // {
4122 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4123 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4124 // }
4125 // else if(mHh>=130.0 && mHh<140.0)
4126 // {
4127 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4128 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4129 // }
4130 // else if(mHh>=140.0 && mHh<145.0)
4131 // {
4132 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4133 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4134 // }
4135 // else if(mHh>=145.0 && mHh<150.0)
4136 // {
4137 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4138 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4139 // }
4140 // else if(mHh>=150.0 && mHh<175.0)
4141 // {
4142 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4143 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4144 // }
4145 // else if(mHh>=175.0 && mHh<200.0)
4146 // {
4147 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4148 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4149 // }
4150 // else if(mHh>=200.0 && mHh<220.0)
4151 // {
4152 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4153 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4154 // }
4155 // else if(mHh>=220.0 && mHh<250.0)
4156 // {
4157 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4158 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4159 // }
4160 // else if(mHh>=250.0 && mHh<260.0)
4161 // {
4162 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4163 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4164 // }
4165 // else if(mHh>=260.0 && mHh<270.0)
4166 // {
4167 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4168 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4169 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4170 // }
4171 // else if(mHh>=270.0 && mHh<275.0)
4172 // {
4173 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4174 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4175 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4176 // }
4177 // else if(mHh>=275.0 && mHh<300.0)
4178 // {
4179 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4180 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4181 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_CMS13(mHh);
4182 // }
4183 // else if(mHh>=300.0 && mHh<350.0)
4184 // {
4185 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4186 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4187 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4188 // }
4189 // else if(mHh>=350.0 && mHh<400.0)
4190 // {
4191 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4192 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4193 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4194 // }
4195 // else if(mHh>=400.0 && mHh<500.0)
4196 // {
4197 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4198 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4199 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4200 // }
4201 // else if(mHh>=500.0 && mHh<550.0)
4202 // {
4203 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4204 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4205 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4206 // }
4207 // else if(mHh>=550.0 && mHh<600.0)
4208 // {
4209 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4210 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4211 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4212 // }
4213 // else if(mHh>=600.0 && mHh<650.0)
4214 // {
4215 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4216 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4217 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4218 // }
4219 // else if(mHh>=650.0 && mHh<760.0)
4220 // {
4221 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4222 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4223 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4224 // }
4225 // else if(mHh>=760.0 && mHh<850.0)
4226 // {
4227 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4228 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4229 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4230 // }
4231 // else if(mHh>=850.0 && mHh<900.0)
4232 // {
4233 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4234 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4235 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4236 // }
4237 // else if(mHh>=900.0 && mHh<1000.0)
4238 // {
4239 // THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4240 // THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4241 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4242 // }
4243 // else if(mHh>=1000.0 && mHh<1100.0)
4244 // {
4245 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4246 // }
4247 // else if(mHh>=1100.0 && mHh<1200.0)
4248 // {
4249 // THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4250 // }
4251 
4252  //95% to 1 sigma conversion factor, roughly sqrt(3.84)
4253  double nftos=1.95996398454;
4254 
4255  if(mHh>= 400.0 && mHh<1000.0) THoEX_tt_H_tt_ATLAS13=tt_H_tt_TH13/ip_ex_tt_phi_tt_ATLAS13(mHh);
4256  if(mA >= 400.0 && mA <1000.0) THoEX_tt_A_tt_ATLAS13=tt_A_tt_TH13/ip_ex_tt_phi_tt_ATLAS13(mA);
4257  if(mHh>= 400.0 && mHh<1000.0) THoEX_bb_H_tt_ATLAS13=bb_H_tt_TH13/ip_ex_bb_phi_tt_ATLAS13(mHh);
4258  if(mA >= 400.0 && mA <1000.0) THoEX_bb_A_tt_ATLAS13=bb_A_tt_TH13/ip_ex_bb_phi_tt_ATLAS13(mA);
4259  if(mHh>= 100.0 && mHh< 900.0) THoEX_bb_H_bb_CMS8=bb_H_bb_TH8/ip_ex_bb_phi_bb_CMS8(mHh);
4260  if(mA >= 100.0 && mA < 900.0) THoEX_bb_A_bb_CMS8=bb_A_bb_TH8/ip_ex_bb_phi_bb_CMS8(mA);
4261  if(mHh>= 330.0 && mHh<1200.0) THoEX_gg_H_bb_CMS8=gg_H_bb_TH8/ip_ex_gg_phi_bb_CMS8(mHh);
4262  if(mA >= 330.0 && mA <1200.0) THoEX_gg_A_bb_CMS8=gg_A_bb_TH8/ip_ex_gg_phi_bb_CMS8(mA);
4263  if(mHh>= 550.0 && mHh<1200.0) THoEX_pp_H_bb_CMS13=pp_H_bb_TH13/ip_ex_pp_phi_bb_CMS13(mHh);
4264  if(mA >= 550.0 && mA <1200.0) THoEX_pp_A_bb_CMS13=pp_A_bb_TH13/ip_ex_pp_phi_bb_CMS13(mA);
4265  if(mHh>= 300.0 && mHh<1300.0) THoEX_bb_H_bb_CMS13=bb_H_bb_TH13/ip_ex_bb_phi_bb_CMS13(mHh);
4266  if(mA >= 300.0 && mA <1300.0) THoEX_bb_A_bb_CMS13=bb_A_bb_TH13/ip_ex_bb_phi_bb_CMS13(mA);
4267  if(mHh>= 90.0 && mHh<1000.0) THoEX_gg_H_tautau_ATLAS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mHh);
4268  if(mA >= 90.0 && mA <1000.0) THoEX_gg_A_tautau_ATLAS8=gg_A_tautau_TH8/ip_ex_gg_phi_tautau_ATLAS8(mA);
4269  if(mHh>= 90.0 && mHh<1000.0) THoEX_gg_H_tautau_CMS8=gg_H_tautau_TH8/ip_ex_gg_phi_tautau_CMS8(mHh);
4270  if(mA >= 90.0 && mA <1000.0) THoEX_gg_A_tautau_CMS8=gg_A_tautau_TH8/ip_ex_gg_phi_tautau_CMS8(mA);
4271  if(mHh>= 90.0 && mHh<1000.0) THoEX_bb_H_tautau_ATLAS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mHh);
4272  if(mA >= 90.0 && mA <1000.0) THoEX_bb_A_tautau_ATLAS8=bb_A_tautau_TH8/ip_ex_bb_phi_tautau_ATLAS8(mA);
4273  if(mHh>= 90.0 && mHh<1000.0) THoEX_bb_H_tautau_CMS8=bb_H_tautau_TH8/ip_ex_bb_phi_tautau_CMS8(mHh);
4274  if(mA >= 90.0 && mA <1000.0) THoEX_bb_A_tautau_CMS8=bb_A_tautau_TH8/ip_ex_bb_phi_tautau_CMS8(mA);
4275  if(mHh>= 200.0 && mHh<2250.0) THoEX_gg_H_tautau_ATLAS13=gg_H_tautau_TH13/ip_ex_gg_phi_tautau_ATLAS13(mHh);
4276  if(mA >= 200.0 && mA <2250.0) THoEX_gg_A_tautau_ATLAS13=gg_A_tautau_TH13/ip_ex_gg_phi_tautau_ATLAS13(mA);
4277  if(mHh>= 90.0 && mHh<3200.0) THoEX_gg_H_tautau_CMS13=gg_H_tautau_TH13/ip_ex_gg_phi_tautau_CMS13(mHh);
4278  if(mA >= 90.0 && mA <3200.0) THoEX_gg_A_tautau_CMS13=gg_A_tautau_TH13/ip_ex_gg_phi_tautau_CMS13(mA);
4279  if(mHh>= 200.0 && mHh<2250.0) THoEX_bb_H_tautau_ATLAS13=bb_H_tautau_TH13/ip_ex_bb_phi_tautau_ATLAS13(mHh);
4280  if(mA >= 200.0 && mA <2250.0) THoEX_bb_A_tautau_ATLAS13=bb_A_tautau_TH13/ip_ex_bb_phi_tautau_ATLAS13(mA);
4281  if(mHh>= 90.0 && mHh<3200.0) THoEX_bb_H_tautau_CMS13=bb_H_tautau_TH13/ip_ex_bb_phi_tautau_CMS13(mHh);
4282  if(mA >= 90.0 && mA <3200.0) THoEX_bb_A_tautau_CMS13=bb_A_tautau_TH13/ip_ex_bb_phi_tautau_CMS13(mA);
4283  if(mHh>= 65.0 && mHh< 600.0) THoEX_gg_H_gaga_ATLAS8=gg_H_gaga_TH8/ip_ex_gg_phi_gaga_ATLAS8(mHh);
4284  if(mA >= 65.0 && mA < 600.0) THoEX_gg_A_gaga_ATLAS8=gg_A_gaga_TH8/ip_ex_gg_phi_gaga_ATLAS8(mA);
4285  if(mHh>= 200.0 && mHh<2700.0) THoEX_pp_H_gaga_ATLAS13=pp_H_gaga_TH13/ip_ex_pp_phi_gaga_ATLAS13(mHh);
4286  if(mA >= 200.0 && mA <2700.0) THoEX_pp_A_gaga_ATLAS13=pp_A_gaga_TH13/ip_ex_pp_phi_gaga_ATLAS13(mA);
4287  if(mH5>= 200.0 && mH5<2700.0) THoEX_pp_H5_gaga_ATLAS13=pp_H5_gaga_TH13/ip_ex_pp_phi_gaga_ATLAS13(mH5);
4288  if(mHh>= 500.0 && mHh<4000.0) THoEX_gg_H_gaga_CMS13=gg_H_gaga_TH13/ip_ex_gg_phi_gaga_CMS13(mHh);
4289  if(mA >= 500.0 && mA <4000.0) THoEX_gg_A_gaga_CMS13=gg_A_gaga_TH13/ip_ex_gg_phi_gaga_CMS13(mA);
4290  if(mHh>= 200.0 && mHh<1600.0) THoEX_pp_H_Zga_llga_ATLAS8=pp_H_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_ATLAS8(mHh);
4291  if(mA >= 200.0 && mA <1600.0) THoEX_pp_A_Zga_llga_ATLAS8=pp_A_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_ATLAS8(mA);
4292  if(mH5>= 200.0 && mH5<1600.0) THoEX_pp_H5_Zga_llga_ATLAS8=pp_H5_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_ATLAS8(mH5);
4293  if(mHh>= 200.0 && mHh<1200.0) THoEX_pp_H_Zga_llga_CMS8=pp_H_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_CMS8(mHh);
4294  if(mA >= 200.0 && mA <1200.0) THoEX_pp_A_Zga_llga_CMS8=pp_A_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_CMS8(mA);
4295  if(mH5>= 200.0 && mH5<1200.0) THoEX_pp_H5_Zga_llga_CMS8=pp_H5_Zga_llga_TH8/ip_ex_pp_phi_Zga_llga_CMS8(mH5);
4296  if(mHh>= 250.0 && mHh<2400.0) THoEX_gg_H_Zga_llga_ATLAS13=gg_H_Zga_TH13/ip_ex_gg_phi_Zga_llga_ATLAS13(mHh);
4297  if(mA >= 250.0 && mA <2400.0) THoEX_gg_A_Zga_llga_ATLAS13=gg_A_Zga_TH13/ip_ex_gg_phi_Zga_llga_ATLAS13(mA);
4298  if(mHh>=1000.0 && mHh<6800.0) THoEX_gg_H_Zga_qqga_ATLAS13=gg_H_Zga_TH13/ip_ex_gg_phi_Zga_qqga_ATLAS13(mHh);
4299  if(mA >=1000.0 && mA <6800.0) THoEX_gg_A_Zga_qqga_ATLAS13=gg_A_Zga_TH13/ip_ex_gg_phi_Zga_qqga_ATLAS13(mA);
4300  if(mHh>= 350.0 && mHh<4000.0) THoEX_gg_H_Zga_CMS13=gg_H_Zga_TH13/ip_ex_gg_phi_Zga_CMS13(mHh);
4301  if(mA >= 350.0 && mA <4000.0) THoEX_gg_A_Zga_CMS13=gg_A_Zga_TH13/ip_ex_gg_phi_Zga_CMS13(mA);
4302  if(mHh>= 140.0 && mHh<1000.0) THoEX_gg_H_ZZ_ATLAS8=gg_H_ZZ_TH8/ip_ex_gg_phi_ZZ_ATLAS8(mHh);
4303  if(mHh>= 140.0 && mHh<1000.0) THoEX_VV_H_ZZ_ATLAS8=VV_H_ZZ_TH8/ip_ex_VV_phi_ZZ_ATLAS8(mHh);
4304  if(mH5>= 140.0 && mH5<1000.0) THoEX_VV_H5_ZZ_ATLAS8=VV_H5_ZZ_TH8/ip_ex_VV_phi_ZZ_ATLAS8(mH5);
4305  if(mHh>= 200.0 && mHh<1200.0) THoEX_gg_H_ZZ_llllnunu_ATLAS13=gg_H_ZZ_TH13/ip_ex_gg_phi_ZZ_llllnunu_ATLAS13(mHh);
4306  if(mHh>= 200.0 && mHh<1200.0) THoEX_VV_H_ZZ_llllnunu_ATLAS13=VV_H_ZZ_TH13/ip_ex_VV_phi_ZZ_llllnunu_ATLAS13(mHh);
4307  if(mH5>= 200.0 && mH5<1200.0) THoEX_VV_H5_ZZ_llllnunu_ATLAS13=VV_H5_ZZ_TH13/ip_ex_VV_phi_ZZ_llllnunu_ATLAS13(mH5);
4308  if(mHh>= 300.0 && mHh<3000.0) THoEX_gg_H_ZZ_qqllnunu_ATLAS13=gg_H_ZZ_TH13/ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13(mHh);
4309  if(mHh>= 300.0 && mHh<3000.0) THoEX_VV_H_ZZ_qqllnunu_ATLAS13=VV_H_ZZ_TH13/ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13(mHh);
4310  if(mH5>= 300.0 && mH5<3000.0) THoEX_VV_H5_ZZ_qqllnunu_ATLAS13=VV_H5_ZZ_TH13/ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13(mH5);
4311  if(mHh>= 130.0 && mHh<3000.0) THoEX_pp_H_ZZ_llqqnunull_CMS13=pp_H_ZZ_TH13/ip_ex_pp_phi_ZZ_llqqnunull_CMS13(mHh);
4312  if(mH5>= 130.0 && mH5<3000.0) THoEX_pp_H5_ZZ_llqqnunull_CMS13=pp_H5_ZZ_TH13/ip_ex_pp_phi_ZZ_llqqnunull_CMS13(mH5);
4313  if(mHh>=1000.0 && mHh<4000.0) THoEX_pp_H_ZZ_qqnunu_CMS13=pp_H_ZZ_TH13/ip_ex_pp_phi_ZZ_qqnunu_CMS13(mHh);
4314  if(mH5>=1000.0 && mH5<4000.0) THoEX_pp_H5_ZZ_qqnunu_CMS13=pp_H5_ZZ_TH13/ip_ex_pp_phi_ZZ_qqnunu_CMS13(mH5);
4315  if(mHh>= 300.0 && mHh<1500.0) THoEX_gg_H_WW_ATLAS8=gg_H_WW_TH8/ip_ex_gg_phi_WW_ATLAS8(mHh);
4316  if(mHh>= 300.0 && mHh<1500.0) THoEX_VV_H_WW_ATLAS8=VV_H_WW_TH8/ip_ex_VV_phi_WW_ATLAS8(mHh);
4317  if(mH5>= 300.0 && mH5<1500.0) THoEX_VV_H5_WW_ATLAS8=VV_H5_WW_TH8/ip_ex_VV_phi_WW_ATLAS8(mH5);
4318  if(mHh>= 250.0 && mHh<4000.0) THoEX_gg_H_WW_enumunu_ATLAS13=gg_H_WW_TH13/ip_ex_gg_phi_WW_enumunu_ATLAS13(mHh);
4319  if(mHh>= 250.0 && mHh<3000.0) THoEX_VV_H_WW_enumunu_ATLAS13=VV_H_WW_TH13/ip_ex_VV_phi_WW_enumunu_ATLAS13(mHh);
4320  if(mH5>= 250.0 && mH5<3000.0) THoEX_VV_H5_WW_enumunu_ATLAS13=VV_H5_WW_TH13/ip_ex_VV_phi_WW_enumunu_ATLAS13(mH5);
4321  if(mHh>= 200.0 && mHh<1000.0) THoEX_ggVV_H_WW_lnulnu_CMS13=ggVV_H_WW_lnulnu_TH13/ip_ex_ggVV_phi_WW_lnulnu_CMS13(mHh);
4322  if(mH5>= 200.0 && mH5<1000.0) THoEX_ggVV_H5_WW_lnulnu_CMS13=ggVV_H5_WW_lnulnu_TH13/ip_ex_ggVV_phi_WW_lnulnu_CMS13(mH5);
4323  if(mHh>= 300.0 && mHh<3000.0) THoEX_gg_H_WW_lnuqq_ATLAS13=gg_H_WW_TH13/ip_ex_gg_phi_WW_lnuqq_ATLAS13(mHh);
4324  if(mHh>= 300.0 && mHh<3000.0) THoEX_VV_H_WW_lnuqq_ATLAS13=VV_H_WW_TH13/ip_ex_VV_phi_WW_lnuqq_ATLAS13(mHh);
4325  if(mH5>= 300.0 && mH5<3000.0) THoEX_VV_H5_WW_lnuqq_ATLAS13=VV_H5_WW_TH13/ip_ex_VV_phi_WW_lnuqq_ATLAS13(mH5);
4326  if(mHh>=1000.0 && mHh<4400.0) THoEX_pp_H_WW_lnuqq_CMS13=pp_H_WW_TH13/ip_ex_pp_phi_WW_lnuqq_CMS13(mHh);
4327  if(mH5>=1000.0 && mH5<4400.0) THoEX_pp_H5_WW_lnuqq_CMS13=pp_H5_WW_TH13/ip_ex_pp_phi_WW_lnuqq_CMS13(mH5);
4328  if(mHh>= 145.0 && mHh<1000.0) THoEX_mu_pp_H_VV_CMS8=mu_pp_H_VV_TH8/ip_ex_mu_pp_phi_VV_CMS8(mHh);
4329  if(mH5>= 145.0 && mH5<1000.0) THoEX_mu_pp_H5_VV_CMS8=mu_pp_H5_VV_TH8/ip_ex_mu_pp_phi_VV_CMS8(mH5);
4330  if(mHh>=1200.0 && mHh<3000.0) THoEX_pp_H_VV_qqqq_ATLAS13=pp_H_VV_TH13/ip_ex_pp_phi_VV_qqqq_ATLAS13(mHh);
4331  if(mH5>=1200.0 && mH5<3000.0) THoEX_pp_H5_VV_qqqq_ATLAS13=pp_H5_VV_TH13/ip_ex_pp_phi_VV_qqqq_ATLAS13(mH5);
4332  if(mHh>= 260.0 && mHh<1000.0) THoEX_gg_H_hh_ATLAS8=gg_H_hh_TH8/ip_ex_gg_phi_hh_ATLAS8(mHh);
4333  if(mHh>= 270.0 && mHh<1100.0) THoEX_pp_H_hh_bbbb_CMS8=pp_H_hh_bbbb_TH8/ip_ex_pp_phi_hh_bbbb_CMS8(mHh);
4334  if(mHh>= 260.0 && mHh<1100.0) THoEX_pp_H_hh_gagabb_CMS8=pp_H_hh_gagabb_TH8/ip_ex_pp_phi_hh_gagabb_CMS8(mHh);
4335  if(mHh>= 260.0 && mHh< 350.0) THoEX_gg_H_hh_bbtautau_CMS8=gg_H_hh_bbtautau_TH8/ip_ex_gg_phi_hh_bbtautau_CMS8(mHh);
4336  if(mHh>= 350.0 && mHh<1000.0) THoEX_pp_H_hh_bbtautau_CMS8=pp_H_hh_TH8/ip_ex_pp_phi_hh_bbtautau_CMS8(mHh);
4337  if(mHh>= 260.0 && mHh<3000.0) THoEX_pp_H_hh_bbbb_ATLAS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_ATLAS13(mHh);
4338  if(mHh>= 260.0 && mHh<1200.0) THoEX_pp_H_hh_bbbb_1_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_1_CMS13(mHh);
4339  if(mHh>=1200.0 && mHh<3000.0) THoEX_pp_H_hh_bbbb_2_CMS13=pp_H_hh_bbbb_TH13/ip_ex_pp_phi_hh_bbbb_2_CMS13(mHh);
4340  if(mHh>=1200.0 && mHh<3000.0) THoEX_gg_H_hh_bbbb_CMS13=gg_H_hh_bbbb_TH13/ip_ex_gg_phi_hh_bbbb_CMS13(mHh);
4341  if(mHh>= 260.0 && mHh<1000.0) THoEX_pp_H_hh_gagabb_ATLAS13=pp_H_hh_gagabb_TH13/(ip_ex_pp_phi_hh_gagabb_ATLAS13(mHh)*0.5809*0.00227);
4342  if(mHh>= 250.0 && mHh< 900.0) THoEX_pp_H_hh_gagabb_CMS13=pp_H_hh_gagabb_TH13/ip_ex_pp_phi_hh_gagabb_CMS13(mHh);
4343  if(mHh>= 260.0 && mHh<1000.0) THoEX_pp_H_hh_bbtautau_ATLAS13=pp_H_hh_bbtautau_TH13/ip_ex_pp_phi_hh_bbtautau_ATLAS13(mHh);
4344  if(mHh>= 250.0 && mHh< 900.0) THoEX_pp_H_hh_bbtautau_1_CMS13=pp_H_hh_bbtautau_TH13/ip_ex_pp_phi_hh_bbtautau_1_CMS13(mHh);
4345  if(mHh>= 900.0 && mHh<4000.0) THoEX_pp_H_hh_bbtautau_2_CMS13=pp_H_hh_bbtautau_TH13/(ip_ex_pp_phi_hh_bbtautau_2_CMS13(mHh)*0.5807*0.06256);
4346  if(mHh>= 260.0 && mHh< 900.0) THoEX_pp_H_hh_bblnulnu_CMS13=pp_H_hh_bblnulnu_TH13/ip_ex_pp_phi_hh_bblnulnu_CMS13(mHh);
4347  if(mHh>= 260.0 && mHh< 500.0) THoEX_gg_H_hh_gagaWW_ATLAS13=gg_H_hh_gagaWW_TH13/ip_ex_gg_phi_hh_gagaWW_ATLAS13(mHh);
4348  if(mA >= 220.0 && mA <1000.0) THoEX_gg_A_hZ_bbZ_ATLAS8=gg_A_hZ_bbZ_TH8/ip_ex_gg_A_hZ_bbZ_ATLAS8(mA);
4349  if(mA >= 225.0 && mA < 600.0) THoEX_gg_A_hZ_bbll_CMS8=gg_A_hZ_bbll_TH8/ip_ex_gg_A_hZ_bbll_CMS8(mA);
4350  if(mA >= 220.0 && mA <1000.0) THoEX_gg_A_hZ_tautauZ_ATLAS8=gg_A_hZ_tautauZ_TH8/ip_ex_gg_A_hZ_tautauZ_ATLAS8(mA);
4351  if(mA >= 220.0 && mA < 350.0) THoEX_gg_A_hZ_tautaull_CMS8=gg_A_hZ_tautaull_TH8/ip_ex_gg_A_hZ_tautaull_CMS8(mA);
4352  if(mA >= 200.0 && mA <2000.0) THoEX_gg_A_hZ_bbZ_ATLAS13=gg_A_hZ_bbZ_TH13/ip_ex_gg_A_hZ_bbZ_ATLAS13(mA);
4353  if(mA >= 200.0 && mA <2000.0) THoEX_bb_A_hZ_bbZ_ATLAS13=bb_A_hZ_bbZ_TH13/ip_ex_bb_A_hZ_bbZ_ATLAS13(mA);
4354  if(mA >= 220.0 && mA < 800.0) THoEX_gg_A_hZ_bbZ_1_CMS13=gg_A_hZ_bbZ_TH13/ip_ex_gg_A_hZ_bbZ_1_CMS13(mA);
4355  if(mA >= 220.0 && mA < 800.0) THoEX_bb_A_hZ_bbZ_1_CMS13=bb_A_hZ_bbZ_TH13/ip_ex_bb_A_hZ_bbZ_1_CMS13(mA);
4356  if(mA >= 800.0 && mA <2000.0) THoEX_gg_A_hZ_bbZ_2_CMS13=gg_A_hZ_bbZ_TH13/ip_ex_gg_A_hZ_bbZ_2_CMS13(mA);
4357  if(mA >= 800.0 && mA <2000.0) THoEX_bb_A_hZ_bbZ_2_CMS13=bb_A_hZ_bbZ_TH13/ip_ex_bb_A_hZ_bbZ_2_CMS13(mA);
4358  if(mHh>= 175.0 && mHh<1000.0 && mA >=40.0 && mA <910.0) THoEX_pp_H_AZ_bbll_CMS8=pp_H_AZ_bbll_TH8/ip_ex_pp_phi_AZ_bbll_CMS8(mA,mHh);
4359  if(mH5>= 175.0 && mH5<1000.0 && mA >=40.0 && mA <910.0) THoEX_pp_H5_AZ_bbll_CMS8=pp_H5_AZ_bbll_TH8/ip_ex_pp_phi_AZ_bbll_CMS8(mA,mH5);
4360  if(mA >= 175.0 && mA <1000.0 && mHh>=50.0 && mHh<910.0) THoEX_pp_A_HZ_bbll_CMS8=pp_A_HZ_bbll_TH8/ip_ex_pp_A_phiZ_bbll_CMS8(mA,mHh);
4361  if(mA >= 230.0 && mA <800.0 && mHh>=130.0 && mHh<700.0) THoEX_gg_A_HZ_bbll_ATLAS13=gg_A_HZ_bbZ_TH13/ip_ex_gg_A_phiZ_bbll_ATLAS13(mA,mHh);
4362  if(mA >= 230.0 && mA <800.0 && mHh>=130.0 && mHh<700.0) THoEX_bb_A_HZ_bbll_ATLAS13=bb_A_HZ_bbZ_TH13/ip_ex_bb_A_phiZ_bbll_ATLAS13(mA,mHh);
4363  if(mA >= 180.0 && mA <1000.0) THoEX_pp_Hpm_taunu_ATLAS8=pp_Hpm_taunu_TH8/ip_ex_pp_Hpm_taunu_ATLAS8(mA);
4364  if(mA >= 180.0 && mA < 600.0) THoEX_pp_Hp_taunu_CMS8=pp_Hp_taunu_TH8/ip_ex_pp_Hp_taunu_CMS8(mA);
4365  if(mA >= 90.0 && mA <2000.0) THoEX_pp_Hpm_taunu_ATLAS13=pp_Hpm_taunu_TH13/ip_ex_pp_Hpm_taunu_ATLAS13(mA);
4366  if(mA >= 180.0 && mA <3000.0) THoEX_pp_Hpm_taunu_CMS13=pp_Hpm_taunu_TH13/ip_ex_pp_Hpm_taunu_CMS13(mA);
4367  if(mA >= 200.0 && mA < 600.0) THoEX_pp_Hpm_tb_ATLAS8=pp_Hpm_tb_TH8/ip_ex_pp_Hpm_tb_ATLAS8(mA);
4368  if(mA >= 180.0 && mA < 600.0) THoEX_pp_Hp_tb_CMS8=pp_Hp_tb_TH8/ip_ex_pp_Hp_tb_CMS8(mA);
4369  if(mA >= 200.0 && mA <2000.0) THoEX_pp_Hpm_tb_ATLAS13=pp_Hpm_tb_TH13/ip_ex_pp_Hpm_tb_ATLAS13(mA);
4370  if(mH5>= 200.0 && mH5<1000.0) THoEX_WZ_H5pm_WZ_qqll_ATLAS8=WZ_H5pm_WZ_TH8/ip_ex_WZ_H5pm_WZ_qqll_ATLAS8(mH5);
4371  if(mH5>= 200.0 && mH5< 900.0) THoEX_WZ_H5pm_WZ_lnull_ATLAS13=WZ_H5pm_WZ_TH13/ip_ex_WZ_H5pm_WZ_lnull_ATLAS13(mH5);
4372  if(mH5>= 200.0 && mH5< 900.0) R_WZ_H5pm_WZ_lnull_ATLAS13=(1+(WZ_H5pm_WZ_TH13-ip_ex_WZ_H5pm_WZ_lnull_ATLAS13(mH5))/ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e(mH5) ) * nftos;
4373  if(mH5>= 200.0 && mH5< 300.0) THoEX_WZ_H5pm_WZ_lnull_1_CMS13=WZ_H5pm_WZ_TH13/ip_ex_WZ_H5pm_WZ_lnull_1_CMS13(mH5);
4374  if(mH5>= 300.0 && mH5<2000.0) THoEX_WZ_H5pm_WZ_lnull_2_CMS13=WZ_H5pm_WZ_TH13/ip_ex_WZ_H5pm_WZ_lnull_2_CMS13(mH5);
4375  if(mH5>= 110.0 && mH5< 600.0) THoEX_pp_H5ppmmH5mmpp_eeee_ATLAS8=pp_H5ppmmH5mmpp_TH8/ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8(mH5);
4376  if(mH5>= 40.0 && mH5< 600.0) THoEX_pp_H5ppmmH5mmpp_emuemu_ATLAS8=pp_H5ppmmH5mmpp_TH8/ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8(mH5);
4377  if(mH5>= 40.0 && mH5< 600.0) THoEX_pp_H5ppmmH5mmpp_mumumumu_ATLAS8=pp_H5ppmmH5mmpp_TH8/ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8(mH5);
4378  if(mH5>= 250.0 && mH5<1200.0) THoEX_pp_H5ppmmH5mmpp_llll_ATLAS13=pp_H5ppmmH5mmpp_TH13/ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13(mH5);
4379  if(mH5>= 200.0 && mH5< 700.0) THoEX_pp_H5ppmmH5mmpp_WWWW_ATLAS13=pp_H5ppmmH5mmpp_WWWW_TH13/ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13(mH5);
4380  if(mH5>= 160.0 && mH5< 800.0) THoEX_VV_H5ppmm_WW_jjll_CMS8=VV_H5ppmm_WW_TH8/ip_ex_VV_H5ppmm_WW_jjll_CMS8(mH5);
4381  if(mH5>= 200.0 && mH5<1000.0) THoEX_VV_H5ppmm_WW_jjll_CMS13=VV_H5ppmm_WW_TH13/ip_ex_VV_H5ppmm_WW_jjll_CMS13(mH5);
4382 
4383 }
4384 
4385 
4386 //void GMcache::runGMparameters()
4387 //{
4390 //
4391 // std::string RGEorder=myGM->getRGEorderflag();
4392 // //flag will be used to transport information about model and RGEorder to the Runner:
4393 // //flag=0 for LO, 1 for approxNLO (and 2 for NLO - not implemented yet)
4394 // int flag;
4395 // if( RGEorder == "LO" ) flag=0;
4396 // else if( RGEorder == "approxNLO" ) flag=1;
4398 // else {
4399 // throw std::runtime_error("RGEorder can be only any of \"LO\", \"approxNLO\" or \"NLO\"");
4400 // }
4401 //
4402 // double lambda1_at_MZ=lambda1;
4403 // double lambda2_at_MZ=lambda2;
4404 // double lambda3_at_MZ=lambda3;
4405 // double lambda4_at_MZ=lambda4;
4406 // double mu1_at_MZ=mu1;
4407 // double mu3_at_MZ=mu3;
4408 // double mu4_at_MZ=mu4;
4409 // double nu1_at_MZ=nu1;
4410 // double omega1_at_MZ=omega1;
4411 // double kappa1_at_MZ=kappa1;
4412 // double nu2_at_MZ=nu2;
4413 // double omega2_at_MZ=omega2;
4414 // double kappa2_at_MZ=kappa2;
4415 // double nu4_at_MZ=nu4;
4416 // double omega4_at_MZ=omega4;
4417 // double NLOuniscale=myGM->getNLOuniscaleGM();
4418 //
4419 // if(fabs(Q_GM-log10(MZ))<0.005) //at MZ scale
4420 // {
4421 // Q_cutoff=log10(MZ);
4422 //
4423 // lambda1_at_Q = lambda1_at_MZ;
4424 // lambda2_at_Q = lambda2_at_MZ;
4425 // lambda3_at_Q = lambda3_at_MZ;
4426 // lambda4_at_Q = lambda4_at_MZ;
4427 // mu1_at_Q = mu1_at_MZ;
4428 // mu3_at_Q = mu3_at_MZ;
4429 // mu4_at_Q = mu4_at_MZ;
4430 // nu1_at_Q = nu1_at_MZ;
4431 // omega1_at_Q = omega1_at_MZ;
4432 // kappa1_at_Q = kappa1_at_MZ;
4433 // nu2_at_Q = nu2_at_MZ;
4434 // omega2_at_Q = omega2_at_MZ;
4435 // kappa2_at_Q = kappa2_at_MZ;
4436 // nu4_at_Q = nu4_at_MZ;
4437 // omega4_at_Q = omega4_at_MZ;
4438 // }
4439 // else //at some other scale
4440 // {
4441 // double InitVals[15];
4442 // InitVals[0]=lambda1_at_MZ;
4443 // InitVals[1]=lambda2_at_MZ;
4444 // InitVals[2]=lambda3_at_MZ;
4445 // InitVals[3]=lambda4_at_MZ;
4446 // InitVals[4]=mu1_at_MZ;
4447 // InitVals[5]=mu3_at_MZ;
4448 // InitVals[6]=mu4_at_MZ;
4449 // InitVals[7]=nu1_at_MZ;
4450 // InitVals[8]=omega1_at_MZ;
4451 // InitVals[9]=kappa1_at_MZ;
4452 // InitVals[10]=nu2_at_MZ;
4453 // InitVals[11]=omega2_at_MZ;
4454 // InitVals[12]=kappa2_at_MZ;
4455 // InitVals[13]=nu4_at_MZ;
4456 // InitVals[14]=omega4_at_MZ;
4457 //
4458 // Q_cutoff=myRunnerGM->RGERunnerGM(InitVals, 15, log10(MZ), Q_GM, flag, RpepsGM, NLOuniscale); //Running up to Q_cutoff<=Q_GM
4459 //
4460 // lambda1_at_Q = InitVals[0];
4461 // lambda2_at_Q = InitVals[1];
4462 // lambda3_at_Q = InitVals[2];
4463 // lambda4_at_Q = InitVals[3];
4464 // mu1_at_Q=InitVals[4];
4465 // mu3_at_Q=InitVals[5];
4466 // mu4_at_Q = InitVals[6];
4467 // nu1_at_Q = InitVals[7];
4468 // omega1_at_Q = InitVals[8];
4469 // kappa1_at_Q = InitVals[9];
4470 // nu2_at_Q = InitVals[10];
4471 // omega2_at_Q = InitVals[11];
4472 // kappa2_at_Q = InitVals[12];
4473 // nu4_at_Q = InitVals[13];
4474 // omega4_at_Q = InitVals[14];
4475 // }
4476 //
4477 //}
4478 
4479 void GMcache::computeUnitarity()
4480 {
4481 // std::string ModelType=myGM->getModelTypeGMflag();
4482 // if( ModelType != "custodial1" )
4483 // {
4484 // throw std::runtime_error("GM unitarity constraints are only implemented for the \"custodial1\" model.");
4485 // }
4486 //
4487  double pi=M_PI;
4488 // /*
4489 // ******* LO part *************
4490 // */
4491 
4492  // Taken from 0712.4053v2, eq. (3.96) to (3.107)
4493  // (all unitarityeigenvalues should be smaller than 0.5 in magnitude)
4494  // Note that when going from their convention to ours, one has to swap lambda3 and lambda4.
4495  unitarityeigenvalues.assign(0, (6.0*lambda1+11.0*lambda2+7.0*lambda3+sqrt((6.0*lambda1-11.0*lambda2-7.0*lambda3)*(6.0*lambda1-11.0*lambda2-7.0*lambda3)+36.0*lambda4*lambda4))/(8.0*pi));
4496  unitarityeigenvalues.assign(1, (6.0*lambda1+11.0*lambda2+7.0*lambda3-sqrt((6.0*lambda1-11.0*lambda2-7.0*lambda3)*(6.0*lambda1-11.0*lambda2-7.0*lambda3)+36.0*lambda4*lambda4))/(8.0*pi));
4497  unitarityeigenvalues.assign(2, (2.0*lambda1+2.0*lambda2-lambda3+sqrt((2.0*lambda1-2.0*lambda2+lambda3)*(2.0*lambda1-2.0*lambda2+lambda3)+lambda5*lambda5))/(8.0*pi));
4498  unitarityeigenvalues.assign(3, (2.0*lambda1+2.0*lambda2-lambda3-sqrt((2.0*lambda1-2.0*lambda2+lambda3)*(2.0*lambda1-2.0*lambda2+lambda3)+lambda5*lambda5))/(8.0*pi));
4499  unitarityeigenvalues.assign(4, (2.0*lambda1+2.0*lambda2+sqrt((2.0*lambda1-2.0*lambda2)*(2.0*lambda1-2.0*lambda2)+lambda5*lambda5))/(8.0*pi));
4500  unitarityeigenvalues.assign(5, (2.0*lambda1+2.0*lambda2-sqrt((2.0*lambda1-2.0*lambda2)*(2.0*lambda1-2.0*lambda2)+lambda5*lambda5))/(8.0*pi));
4501  unitarityeigenvalues.assign(6, (4.0*lambda1+2.0*lambda2-lambda3+sqrt((4.0*lambda1-2.0*lambda2+lambda3)*(4.0*lambda1-2.0*lambda2+lambda3)+2.0*lambda5*lambda5))/(8.0*pi));
4502  unitarityeigenvalues.assign(7, (4.0*lambda1+2.0*lambda2-lambda3-sqrt((4.0*lambda1-2.0*lambda2+lambda3)*(4.0*lambda1-2.0*lambda2+lambda3)+2.0*lambda5*lambda5))/(8.0*pi));
4503  unitarityeigenvalues.assign(8, (6.0*lambda2+7.0*lambda3+sqrt(4.0*lambda2*lambda2+4.0*lambda2*lambda3+17.0*lambda3*lambda3))/(8.0*pi));
4504  unitarityeigenvalues.assign(9, (6.0*lambda2+7.0*lambda3-sqrt(4.0*lambda2*lambda2+4.0*lambda2*lambda3+17.0*lambda3*lambda3))/(8.0*pi));
4505  unitarityeigenvalues.assign(10, (lambda2+2.0*lambda3)/(2.0*pi));
4506  unitarityeigenvalues.assign(11, (2.0*lambda2+lambda3)/(4.0*pi));
4507  unitarityeigenvalues.assign(12, (4.0*lambda4+lambda5)/(16.0*pi));
4508  unitarityeigenvalues.assign(13, (2.0*lambda4-lambda5)/(8.0*pi));
4509  unitarityeigenvalues.assign(14, (lambda4+lambda5)/(4.0*pi));
4510  unitarityeigenvalues.assign(15, (2.0*lambda2+(2.0*sqrt(2.0))*lambda3)/(4.0*pi));
4511  unitarityeigenvalues.assign(16, (2.0*lambda2+(2.0*sqrt(2.0))*lambda3)/(4.0*pi));
4512 
4513  /*
4514  ******* NLO part *************
4515  */
4516 
4517  // beta functions taken from
4518 // double blambda1=(12.0*lambda1*lambda1 + 4.0*lambda3*lambda3 + 4.0*lambda3*lambda4 + 4.0*lambda4*lambda4
4519 // + 8.0*nu1*nu1 + 8.0*nu1*nu2 + 8.0*nu2*nu2)/(16.0*pi*pi);
4520 // double blambda2=(12.0*lambda2*lambda2 + 4.0*lambda3*lambda3 + 4.0*lambda3*lambda4 + 4.0*lambda4*lambda4
4521 // + 8.0*omega1*omega1 + 8.0*omega1*omega2 + 8.0*omega2*omega2)/(16.0*pi*pi);
4522 // double blambda3=(4.0*lambda3*lambda3 + 4.0*lambda4*lambda4 + (lambda1+lambda2)*(6.0*lambda3+2.0*lambda4)
4523 // + 8.0*kappa2*kappa2 + 8.0*nu1*omega1 + 4.0*nu2*omega1 + 4.0*nu1*omega2)/(16.0*pi*pi);
4524 // double blambda4=(lambda1*lambda4 + lambda2*lambda4 + 4.0*lambda3*lambda4 + 6.0*lambda4*lambda4
4525 // + 4.0*kappa1*kappa1 + 4.0*kappa1*kappa2 + 2.0*kappa2*kappa2 + 2.0*nu2*omega2)/(8.0*pi*pi);
4526 // double bmu1=(11.0*mu1*mu1 + 3.0*mu1*mu4 + mu1*(2.0*mu1+6.0*mu3+3.0*mu4)
4527 // + 3.0*nu4*nu4 + 3.0*omega4*omega4)/(16.0*pi*pi);
4528 // double bmu3=(18.0*kappa1*kappa1 + 18.0*kappa1*kappa2 + 134.0*mu1*mu1 + 6.0*mu1*(39.0*mu3 + 22.0*mu4)
4529 // + 3.0*(30.0*mu3*mu3 + 39.0*mu3*mu4 + 9.0*mu4*mu4
4530 // + 3.0*nu1*nu1 + 3.0*nu1*nu2 - 5.0*nu4*nu4
4531 // + 3.0*omega1*omega1 + 3.0*omega1*omega2 - 5.0*omega4*omega4))/(72.0*pi*pi);
4532 // double bmu4=(18.0*kappa2*kappa2 + 4.0*mu1*mu1 + 156.0*mu1*mu4 + 54.0*mu3*mu4 + 144.0*mu4*mu4
4533 // + 9.0*nu2*nu2 + 6.0*nu4*nu4 + 9.0*omega2*omega2 + 6.0*omega4*omega4)/(144.0*pi*pi);
4534 // double bnu1=(6.0*kappa1*kappa1 + 6.0*kappa2*kappa2 + 18.0*lambda1*nu1
4535 // + 78.0*mu1*nu1 + 51.0*mu3*nu1 + 39.0*mu4*nu1 + 6.0*nu1*nu1
4536 // + 6.0*lambda1*nu2 + 32.0*mu1*nu2 + 24.0*mu3*nu2 + 6.0*mu4*nu2
4537 // + 6.0*nu2*nu2 + 10.0*nu4*nu4
4538 // + 12.0*lambda3*omega1 + 6.0*lambda4*omega1 + 6.0*lambda3*omega2)/(48.0*pi*pi);
4539 // double bomega1=(6.0*kappa1*kappa1 + 6.0*kappa2*kappa2
4540 // + 12.0*lambda3*nu1 + 6.0*lambda4*nu1 + 6.0*lambda3*nu2
4541 // + 18.0*lambda2*omega1 + 78.0*mu1*omega1 + 51.0*mu3*omega1 + 39.0*mu4*omega1 + 6.0*omega1*omega1
4542 // + 6.0*lambda2*omega2 + 32.0*mu1*omega2 + 24.0*mu3*omega2 + 6.0*mu4*omega2 + 6.0*omega2*omega2
4543 // + 10.0*omega4*omega4)/(48.0*pi*pi);
4544 // double bkappa1=(6.0*kappa1*(2.0*lambda3 + 10.0*lambda4 + 18.0*mu1 + 17.0*mu3 + 13.0*mu4 + 2.0*nu1 + 2.0*omega1)
4545 // + kappa2*(24.0*lambda4 + 64.0*mu1 + 48.0*mu3 + 24.0*mu4 + 9.0*nu2 + 9.0*omega2)
4546 // + 20.0*nu4*omega4)/(96.0*pi*pi);
4547 // double bnu2=(4.0*kappa1*kappa2 + 6.0*kappa2*kappa2 + 2.0*lambda1*nu2 + ((14.0*mu1)/3.0 + mu3 + 9.0*mu4)*nu2
4548 // + 4.0*nu1*nu2 + 6.0*nu2*nu2 + (25.0*nu4*nu4)/3.0 + 2.0*lambda4*omega2)/(16.0*pi*pi);
4549 // double bomega2=(4.0*kappa1*kappa2 + 6.0*kappa2*kappa2 + 2.0*lambda4*nu2 + 2.0*lambda2*omega2
4550 // + ((14.0*mu1)/3.0 + mu3 + 9.0*mu4)*omega2 + 4.0*omega1*omega2 + 6.0*omega2*omega2
4551 // + (25.0*omega4*omega4)/3.0)/(16.0*pi*pi);
4552 // double bkappa2=(kappa2*(6.0*lambda3 + 6.0*lambda4 + 14.0*mu1 + 3.0*mu3 + 27.0*mu4
4553 // + 6.0*nu1 + 12.0*nu2 + 6.0*omega1 + 12.0*omega2)
4554 // + 6.0*kappa1*(nu2 + omega2) + 42.0*nu4*omega4)/(48.0*pi*pi);
4555 // double bnu4=(11.0*mu1*nu4 + 3.0*mu3*nu4 + 9.0*mu4*nu4 + 3.0*nu1*nu4 + 9.0*nu2*nu4
4556 // + 3.0*kappa1*omega4 + 9.0*kappa2*omega4)/(16.0*pi*pi);
4557 // double bomega4=(3.0*kappa1*nu4 + 9.0*kappa2*nu4
4558 // + (11.0*mu1 + 3.0*(mu3 + 3.0*mu4 + omega1 + 3.0*omega2))*omega4)/(16.0*pi*pi);
4559 //
4560 // Sbmatrix1.assign(0,0, 3.0*blambda1/(16.0*pi));
4561 // Sbmatrix1.assign(0,1, (2.0*blambda3+blambda4)/(16.0*pi));
4562 // Sbmatrix1.assign(1,0, Sbmatrix1(0,1));
4563 // Sbmatrix1.assign(0,3, (2.0*bnu1+bnu2)/(8.0*sqrt(2.0)*pi));
4564 // Sbmatrix1.assign(3,0, Sbmatrix1(0,3));
4565 // Sbmatrix1.assign(1,1, 3.0*blambda2/(16.0*pi));
4566 // Sbmatrix1.assign(1,3, (2.0*bomega1+bomega2)/(8.0*sqrt(2.0)*pi));
4567 // Sbmatrix1.assign(3,1, Sbmatrix1(1,3));
4568 // Sbmatrix1.assign(2,2, (blambda3+5.0*blambda4)/(16.0*pi));
4569 // Sbmatrix1.assign(2,3, (4.0*bkappa1+2.0*bkappa2)/(16.0*pi));
4570 // Sbmatrix1.assign(3,2, Sbmatrix1(2,3));
4571 // Sbmatrix1.assign(3,3, (26.0*bmu1+17.0*bmu3+13.0*bmu4)/(32.0*pi));
4572 //
4573 // Sbmatrix2.assign(0,0, blambda1/(16.0*pi));
4574 // Sbmatrix2.assign(0,1, blambda4/(16.0*pi));
4575 // Sbmatrix2.assign(1,0, Sbmatrix2(0,1));
4576 // Sbmatrix2.assign(0,3, bnu2/(8.0*sqrt(2.0)*pi));
4577 // Sbmatrix2.assign(3,0, Sbmatrix2(0,3));
4578 // Sbmatrix2.assign(1,1, blambda2/(16.0*pi));
4579 // Sbmatrix2.assign(1,3, bomega2/(8.0*sqrt(2.0)*pi));
4580 // Sbmatrix2.assign(3,1, Sbmatrix2(1,3));
4581 // Sbmatrix2.assign(2,2, (blambda3+blambda4)/(16.0*pi));
4582 // Sbmatrix2.assign(2,3, bkappa2/(8.0*pi));
4583 // Sbmatrix2.assign(3,2, Sbmatrix2(2,3));
4584 // Sbmatrix2.assign(3,3, (14.0*bmu1+3.0*bmu3+27.0*bmu4)/(96.0*pi));
4585 //
4586 // Seigenvectors1T=Seigenvectors1.hconjugate();
4587 // Seigenvectors2T=Seigenvectors2.hconjugate();
4588 //
4589 // for (int i=0; i < 4; i++) {
4590 // for (int k=0; k < 4; k++) {
4591 // for (int l=0; l < 4; l++) {
4592 // Sbeigenvalues1.assign(i, Sbeigenvalues1(i) + Seigenvectors1T(i,k) * Sbmatrix1(k,l) * Seigenvectors1(l,i) );
4593 // Sbeigenvalues2.assign(i, Sbeigenvalues2(i) + Seigenvectors2T(i,k) * Sbmatrix2(k,l) * Seigenvectors2(l,i) );
4594 // }
4595 // }
4596 // betaeigenvalues.assign(i, -1.5 * Sbeigenvalues1(i));
4597 // betaeigenvalues.assign(i+4, -1.5 * Sbeigenvalues2(i));
4598 // }
4599 //
4600 // betaeigenvalues.assign(8, -1.5 * (blambda3-blambda4)/(16.0*pi));
4601 // betaeigenvalues.assign(9, -1.5 * sqrt(15.0)*bnu4/(16.0*pi));
4602 // betaeigenvalues.assign(10, -1.5 * sqrt(15.0)*bomega4/(16.0*pi));
4603 //
4604 // for (int i=0; i < 11; i++) {
4605 // NLOunitarityeigenvalues.assign(i, -(gslpp::complex::i()-1.0/pi)*unitarityeigenvalues(i)*unitarityeigenvalues(i) + betaeigenvalues(i) );
4606 // }
4607 }
4608 
4609 double GMcache::cW2GM(const double c02) const{
4610  return c02;
4611 }
4612 
4613 
4614 double GMcache::updateCache()
4615 {
4616 // GMmodel=myGM->getModelTypeGMflag();
4617  Q_GM=myGM->getQ_GM();
4618  vev=myGM->v();
4619  mHl=myGM->getMHl();
4620  mHl2=mHl*mHl;
4621  GF=1/(sqrt(2.0)*vev*vev);
4622  Ale=myGM->getAle();
4623  MZ=myGM->getMz();
4624  MW=myGM->Mw();
4625  cW2=cW2GM(myGM->c02()); /*This might have to be replaced by the GM corrected value.*/
4626  vDelta=myGM->getvDelta();
4627  cosb=sqrt(8.0)*vDelta/vev;
4628  if(cosb<=1.0) {
4629  sinb=sqrt(1.0-cosb*cosb);
4630  }
4631  else {
4632  sinb=std::numeric_limits<double>::quiet_NaN();
4633  }
4634  tanb=sinb/cosb;
4635 // logtb=log10(tanb);
4636  vPhi=vev*sinb;
4637  sina=myGM->getsina();
4638  cosa=myGM->getcosa();
4639  mH1sq=myGM->getinputmHh2();
4640  mAsq=myGM->getmAsq();
4641  mH5sq=myGM->getmH5sq();
4642  Mu1=myGM->getMu1();
4643  Mu2=myGM->getMu2();
4644  M1sq=-vev*Mu1/(sqrt(2.0)*cosb);
4645  M2sq=-sqrt(18.0)*cosb*vev*Mu2;
4646 
4647  double mHlsq, mHhsq;
4648  if(mH1sq>=mHl2)
4649  {
4650  mHlsq=mHl2;
4651  mHhsq=mH1sq;
4652  }
4653  else
4654  {
4655  mHlsq=mH1sq;
4656  mHhsq=mHl2;
4657  }
4658 
4659 // double cos2b=cosb*cosb-sinb*sinb;
4660  lambda1 = (mHlsq*cosa*cosa+mHhsq*sina*sina)/(8.0*vev*vev*sinb*sinb);
4661  lambda2 = (M2sq+2.0*(mAsq-M1sq)*sinb*sinb
4662  +2.0/3.0*(mHlsq*sina*sina+mHhsq*cosa*cosa-mH5sq))/(2.0*vev*vev*cosb*cosb);
4663  lambda3 = (mH5sq-M2sq+(2.0*M1sq-3.0*mAsq)*sinb*sinb)/(vev*vev*cosb*cosb);
4664  lambda4 = (mAsq-0.5*M1sq+(mHhsq-mHlsq)*sina*cosa/(sqrt(6.0)*sinb*cosb))/(vev*vev);
4665  lambda5 = 2.0*(M1sq-mAsq)/(vev*vev);
4666 
4667  //triple scalar couplings
4668  ghhh = -(2.0*sina*sina*sinb*(3.0*cosa+sqrt(6.0)*sina*tanb))/vev * M1sq
4669  +(sqrt(2.0/3.0)*sina*sina*sina)/(vev*cosb) * M2sq
4670  +(-3.0*cosa*cosa*cosa/sinb+2.0*sqrt(6.0)*sina*sina*sina/cosb)/vev * mHlsq;
4671  ghhH = sina*sinb*(4.0-6.0*sina*sina+2.0*sqrt(6.0)*sina*cosa*tanb)/vev * M1sq
4672  -(sqrt(2.0/3.0)*cosa*sina*sina)/(vev*cosb) * M2sq
4673  -sina*(cosa*cosa/sinb+2.0*sqrt(2.0/3.0)*sina*cosa/cosb)/vev * (2.0*mHlsq+mHhsq);
4674  ghHH = cosa*sinb*(4.0-6.0*cosa*cosa-2.0*sqrt(6.0)*sina*cosa*tanb)/vev * M1sq
4675  +(sqrt(2.0/3.0)*cosa*cosa*sina)/(vev*cosb) * M2sq
4676  +cosa*(-sina*sina/sinb+2.0*sqrt(2.0/3.0)*sina*cosa/cosb)/vev * (mHlsq+2.0*mHhsq);
4677  gHHH = (2.0*cosa*cosa*sinb*(-3.0*sina+sqrt(6.0)*cosa*tanb))/vev * M1sq
4678  -(sqrt(2.0/3.0)*cosa*cosa*cosa)/(vev*cosb) * M2sq
4679  -(3.0*sina*sina*sina/sinb+2.0*sqrt(6.0)*cosa*cosa*cosa/cosb)/vev * mHhsq;
4680  ghH3H3 = -(2.0*sqrt(2.0/3.0)*sina)/(vev*cosb) * M1sq
4681  +(4.0*sqrt(2.0/3.0)*sina*cosb-2.0*cosa*sinb)/vev * mAsq
4682  +(2.0*sqrt(2.0/3.0)*sina*sinb*tanb-cosa*cosb/tanb)/vev * mHlsq;
4683  gHH3H3 = (2.0*sqrt(2.0/3.0)*cosa)/(vev*cosb) * M1sq
4684  -(4.0*sqrt(2.0/3.0)*cosa*cosb+2.0*sina*sinb)/vev * mAsq
4685  -(2.0*sqrt(2.0/3.0)*cosa*sinb*tanb+sina*cosb/tanb)/vev * mHhsq;
4686  ghH3pH3m = ghH3H3;
4687  gHH3pH3m = gHH3H3;
4688  ghH5H5 = 2.0*sinb*(2.0*cosa+sqrt(6.0)*sina*tanb)/vev * (M1sq-2.0*mAsq)
4689  +(2.0*sqrt(2.0/3.0)*sina)/(vev*cosb) * (mHlsq + 2.0*mH5sq - M2sq)
4690  +(2.0*cosa*sinb)/vev * mAsq;
4691  gHH5H5 = 2.0*sinb*(2.0*sina-sqrt(6.0)*cosa*tanb)/vev * (M1sq-2.0*mAsq)
4692  -(2.0*sqrt(2.0/3.0)*cosa)/(vev*cosb) * (mHhsq + 2.0*mH5sq - M2sq)
4693  +(2.0*sina*sinb)/vev * mAsq;
4694  ghH5pH5m = ghH5H5;
4695  gHH5pH5m = gHH5H5;
4696  ghH5ppH5mm = ghH5H5;
4697  gHH5ppH5mm = gHH5H5;
4698  gH3H3H5 = -2.0*((mH5sq-2.0*mAsq)*cosb-(2.0*M1sq-3.0*mAsq+mH5sq)/cosb)/(sqrt(3.0)*vev);
4699  gH5H5H5 = 2.0*((3.0*mH5sq-4.0*M2sq)/cosb+(6.0*M1sq-9.0*mAsq)*sinb*tanb)/(sqrt(3.0)*vev);
4700  gH3H3pH5m = gslpp::complex::i()*(4.0*M1sq-4.0*mAsq+mH5sq+(2.0*mAsq-mH5sq)*(cosb*cosb-sinb*sinb))/(2.0*vev*cosb);
4701  gH5H3pH3m = -0.5*gH3H3H5;
4702  gH5H5pH5m = 0.5*gH5H5H5;
4703  gH5H5ppH5mm = -gH5H5H5;
4704  gH5ppH3mH3m = sqrt(6.0)*gH5H3pH3m;
4705  gH5ppH5mH5m = -sqrt(2.0)*(4.0*M2sq-3.0*mH5sq-(6.0*M1sq-9.0*mAsq)*sinb*sinb)/(vev*cosb);
4706 // std::cout<<"ghhh = "<<ghhh<<std::endl;
4707 // std::cout<<"ghhH = "<<ghhH<<std::endl;
4708 // std::cout<<"ghHH = "<<ghHH<<std::endl;
4709 // std::cout<<"gHHH = "<<gHHH<<std::endl;
4710 // std::cout<<"ghH3H3 = "<<ghH3H3<<std::endl;
4711 // std::cout<<"gHH3H3 = "<<gHH3H3<<std::endl;
4712 // std::cout<<"ghH5H5 = "<<ghH5H5<<std::endl;
4713 // std::cout<<"gHH5H5 = "<<gHH5H5<<std::endl;
4714 // std::cout<<"gH3H3H5 = "<<gH3H3H5<<std::endl;
4715 // std::cout<<"gH5H5H5 = "<<gH5H5H5<<std::endl;
4716 // std::cout<<"gH3H3pH5m = "<<gH3H3pH5m<<std::endl;
4717 // std::cout<<"gH5H3pH3m = "<<gH5H3pH3m<<std::endl;
4718 // std::cout<<"gH5ppH3mH3m = "<<gH5ppH3mH3m<<std::endl;
4719 // std::cout<<"gH5ppH5mH5m = "<<gH5ppH5mH5m<<std::endl;
4720 
4721  // runGMparameters();
4722  computeUnitarity();
4723  computeSignalStrengthQuantities();
4724  computeDirectSearchQuantities();
4725  return mHl2;
4726 }
QCD::TAU
Definition: QCD.h:316
GMcache::ip_ex_gg_phi_tautau_CMS8
double ip_ex_gg_phi_tautau_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1469
GMcache::pp_H_VV_TH8
double pp_H_VV_TH8
Definition: GMcache.h:1050
GMcache::CMS8_mu_pp_phi_VV
gslpp::matrix< double > CMS8_mu_pp_phi_VV
Definition: GMcache.h:130
GMcache::CMS13_bb_A_Zh_Zbb_2
gslpp::matrix< double > CMS13_bb_A_Zh_Zbb_2
Definition: GMcache.h:130
GMcache::mH1sq
double mH1sq
Definition: GMcache.h:1425
GMcache::I_h_D
gslpp::complex I_h_D(const double mHl2, const double Md, const double Ms, const double Mb) const
Definition: GMcache.cpp:2778
GMcache::CMS13_bb_phi_tautau
gslpp::matrix< double > CMS13_bb_phi_tautau
Definition: GMcache.h:130
GMcache::gg_A_hZ_bbZ_TH8
double gg_A_hZ_bbZ_TH8
Definition: GMcache.h:1063
GMcache::ip_ex_bb_phi_bb_CMS8
double ip_ex_bb_phi_bb_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1399
GMcache::ATLAS13_VV_phi_WW_lnuqq
gslpp::matrix< double > ATLAS13_VV_phi_WW_lnuqq
Definition: GMcache.h:130
GMcache::ATLAS13_gg_A_phiZ_bbll
gslpp::matrix< double > ATLAS13_gg_A_phiZ_bbll
Definition: GMcache.h:130
GMcache::VV_H5ppmm_WW_TH8
double VV_H5ppmm_WW_TH8
Definition: GMcache.h:1070
GMcache::ip_ex_pp_phi_WW_lnuqq_CMS13_cache
double ip_ex_pp_phi_WW_lnuqq_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1524
GMcache::vDelta
double vDelta
Definition: GMcache.h:1422
GMcache::THoEX_pp_H_WW_lnuqq_CMS13
double THoEX_pp_H_WW_lnuqq_CMS13
Definition: GMcache.h:965
GMcache::log_cs_VBFH5_13
gslpp::matrix< double > log_cs_VBFH5_13
Definition: GMcache.h:121
GMcache::ATLAS13_pp_Hpm_taunu
gslpp::matrix< double > ATLAS13_pp_Hpm_taunu
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_AZ_bbll_CMS8
double ip_ex_pp_phi_AZ_bbll_CMS8(double mH, double mA)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2323
GMcache::THoEX_VV_H_ZZ_ATLAS8
double THoEX_VV_H_ZZ_ATLAS8
Definition: GMcache.h:958
GMcache::CMS13_bb_A_Zh_Zbb_1
gslpp::matrix< double > CMS13_bb_A_Zh_Zbb_1
Definition: GMcache.h:130
GMcache::cosa
double cosa
Definition: GMcache.h:1424
GMcache::ip_Br_HPtoZZ_cache
double ip_Br_HPtoZZ_cache[2][CacheSize]
Definition: GMcache.h:1445
GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS13
double ip_ex_VV_H5ppmm_WW_jjll_CMS13(double mH5)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2617
GMcache::A_h_L
gslpp::complex A_h_L(const double mHl2, const double cW2, const double Me, const double Mmu, const double Mtau, const double MZ) const
Definition: GMcache.cpp:3033
GMcache::ip_ex_VV_phi_ZZ_ATLAS8
double ip_ex_VV_phi_ZZ_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1693
GMcache::THoEX_bb_A_hZ_bbZ_1_CMS13
double THoEX_bb_A_hZ_bbZ_1_CMS13
Definition: GMcache.h:980
GMcache::THoEX_gg_A_tautau_CMS13
double THoEX_gg_A_tautau_CMS13
Definition: GMcache.h:951
GMcache::ip_ex_gg_A_phiZ_bbll_ATLAS13_cache
double ip_ex_gg_A_phiZ_bbll_ATLAS13_cache[3][CacheSize]
Definition: GMcache.h:1555
GMcache::ip_Br_HPtomumu_cache
double ip_Br_HPtomumu_cache[2][CacheSize]
Definition: GMcache.h:1444
GMcache::THoEX_pp_H_gaga_ATLAS13
double THoEX_pp_H_gaga_ATLAS13
Definition: GMcache.h:952
GMcache::Br_H5togaga
double Br_H5togaga
Definition: GMcache.h:940
GMcache::I_H_W
gslpp::complex I_H_W(const double mH, const double MW) const
Definition: GMcache.cpp:2881
GMcache::ip_ex_gg_phi_ZZ_ATLAS8
double ip_ex_gg_phi_ZZ_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1679
GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS8_cache
double ip_ex_gg_A_hZ_bbZ_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1543
GMcache::THoEX_pp_H_AZ_bbll_CMS8
double THoEX_pp_H_AZ_bbll_CMS8
Definition: GMcache.h:983
StandardModel::v
virtual double v() const
The Higgs vacuum expectation value.
Definition: StandardModel.cpp:917
GMcache::ip_Br_HPtoWW
double ip_Br_HPtoWW(double mass)
Interpolating function for the SM branching ratio to two bosons.
Definition: GMcache.cpp:618
GMcache::ip_ex_gg_phi_Zga_llga_ATLAS13_cache
double ip_ex_gg_phi_Zga_llga_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1505
GMcache::ip_cs_VBFtoH_8
double ip_cs_VBFtoH_8(double mass)
Interpolating function for the H production cross section via vector boson fusion at 8 TeV.
Definition: GMcache.cpp:687
GMcache::pp_H_WW_TH13
double pp_H_WW_TH13
Definition: GMcache.h:1048
GMcache::CMS13_gg_A_Zh_Zbb_2
gslpp::matrix< double > CMS13_gg_A_Zh_Zbb_2
Definition: GMcache.h:130
GMcache::pp_H_hh_TH13
double pp_H_hh_TH13
Definition: GMcache.h:1061
GMcache::ip_cs_pptottA_13
double ip_cs_pptottA_13(double mass)
Interpolating function for the top associated A production cross section at 13 TeV.
Definition: GMcache.cpp:934
GMcache::Br_H5toHpW
double Br_H5toHpW
Definition: GMcache.h:940
GMcache::gg_H_hh_gagaWW_TH13
double gg_H_hh_gagaWW_TH13
Definition: GMcache.h:1061
GMcache::gHH5pH5m
double gHH5pH5m
Definition: GMcache.h:1009
GMcache::ip_ex_bb_phi_tautau_CMS8_cache
double ip_ex_bb_phi_tautau_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1495
GMcache::ip_cs_WtoWH_8
double ip_cs_WtoWH_8(double mass)
Interpolating function for the W associated H production cross section at 8 TeV.
Definition: GMcache.cpp:725
GMcache::ip_ex_gg_A_phiZ_bbll_ATLAS13
double ip_ex_gg_A_phiZ_bbll_ATLAS13(double mA, double mH)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2337
GMcache::updateCache
double updateCache()
Definition: GMcache.cpp:4614
GMcache::ip_cs_ggtoA_13_cache
double ip_cs_ggtoA_13_cache[2][CacheSize]
Definition: GMcache.h:1461
GMcache::ghH3pH3m
double ghH3pH3m
Definition: GMcache.h:1004
QCD::BOTTOM
Definition: QCD.h:329
GMcache::ip_cs_VBFH5pp_13
double ip_cs_VBFH5pp_13(double mass)
Definition: GMcache.cpp:1238
GMcache::THoEX_gg_A_gaga_ATLAS8
double THoEX_gg_A_gaga_ATLAS8
Definition: GMcache.h:953
GMcache::Br_HptoH5pZ
double Br_HptoH5pZ
Definition: GMcache.h:939
GMcache::THoEX_pp_H5_hh_bblnulnu_CMS13
double THoEX_pp_H5_hh_bblnulnu_CMS13
Definition: GMcache.h:977
GMcache::gg_H_WW_TH8
double gg_H_WW_TH8
Definition: GMcache.h:1048
GMcache::VV_H_ZZ_TH13
double VV_H_ZZ_TH13
Definition: GMcache.h:1046
GMcache::ip_ex_pp_Hp_tb_CMS8_cache
double ip_ex_pp_Hp_tb_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1562
GMcache::ip_Br_HPtomumu
double ip_Br_HPtomumu(double mass)
Interpolating function for the SM branching ratio to two muons.
Definition: GMcache.cpp:586
GMcache::I_HH_U
gslpp::complex I_HH_U(const double mHh2, const double Mc, const double Mt) const
Definition: GMcache.cpp:2745
GMcache::ip_ex_pp_phi_Zga_llga_ATLAS8
double ip_ex_pp_phi_Zga_llga_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1609
GMcache::Br_HtoWW
double Br_HtoWW
Definition: GMcache.h:936
GMcache::THoEX_bb_H_bb_CMS13
double THoEX_bb_H_bb_CMS13
Definition: GMcache.h:946
GMcache::ip_ex_pp_phi_hh_bbtautau_ATLAS13_cache
double ip_ex_pp_phi_hh_bbtautau_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1538
GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS13_cache
double ip_ex_gg_A_hZ_bbZ_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1547
GMcache::ip_ex_gg_phi_Zga_llga_ATLAS13
double ip_ex_gg_phi_Zga_llga_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1637
GMcache::ATLAS13_gg_phi_Zga_qqga
gslpp::matrix< double > ATLAS13_gg_phi_Zga_qqga
Definition: GMcache.h:130
GMcache::THoEX_pp_H_hh_bbbb_ATLAS13
double THoEX_pp_H_hh_bbbb_ATLAS13
Definition: GMcache.h:971
GMcache::bb_H_tt_TH13
double bb_H_tt_TH13
Definition: GMcache.h:1021
GMcache::Mu1
double Mu1
Definition: GMcache.h:1428
GMcache::ip_cs_VBFH5_13_cache
double ip_cs_VBFH5_13_cache[2][CacheSize]
Definition: GMcache.h:1471
GMcache::THoEX_gg_H_ZZ_llllnunu_ATLAS13
double THoEX_gg_H_ZZ_llllnunu_ATLAS13
Definition: GMcache.h:958
GMcache::ip_ex_VV_phi_ZZ_llllnunu_ATLAS13_cache
double ip_ex_VV_phi_ZZ_llllnunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1511
gslpp::matrix< double >::assign
void assign(const size_t &i, const size_t &j, const double &a)
Definition: gslpp_matrix_double.cpp:108
GMcache::GammaH5tot
double GammaH5tot
Total decay width of the CP-even Higgs .
Definition: GMcache.h:1094
GeorgiMachacek::getmH5sq
double getmH5sq() const
A method to get the squared quintet mass.
Definition: GeorgiMachacek.h:377
GMcache::ghhH
double ghhH
Definition: GMcache.h:999
GMcache::THoEX_gg_A_hZ_tautauZ_ATLAS8
double THoEX_gg_A_hZ_tautauZ_ATLAS8
Definition: GMcache.h:978
GMcache::gg_H_gaga_TH13
double gg_H_gaga_TH13
Definition: GMcache.h:1040
GMcache::GMcache
GMcache(const StandardModel &SM_i)
GMcache constructor.
Definition: GMcache.cpp:14
GMcache::Br_H5toAA
double Br_H5toAA
Definition: GMcache.h:940
GMcache::THoEX_gg_H_hh_bbbb_CMS13
double THoEX_gg_H_hh_bbbb_CMS13
Definition: GMcache.h:972
GMcache::pp_H_hh_gagabb_TH13
double pp_H_hh_gagabb_TH13
Definition: GMcache.h:1061
gslpp::matrix< double >
A class for constructing and defining operations on real matrices.
Definition: gslpp_matrix_double.h:48
GMcache::OffShellFunction_cache
double OffShellFunction_cache[1][CacheSize]
Definition: GMcache.h:1577
GMcache::THoEX_VV_H5_ZZ_qqllnunu_ATLAS13
double THoEX_VV_H5_ZZ_qqllnunu_ATLAS13
Definition: GMcache.h:962
GMcache::ATLAS8_gg_phi_tautau
gslpp::matrix< double > ATLAS8_gg_phi_tautau
Definition: GMcache.h:130
GMcache::THoEX_tt_A_tt_ATLAS13
double THoEX_tt_A_tt_ATLAS13
Definition: GMcache.h:945
GMcache::f_func
gslpp::complex f_func(const double x) const
Definition: GMcache.cpp:3130
GMcache::THoEX_pp_H5_hh_gagabb_ATLAS13
double THoEX_pp_H5_hh_gagabb_ATLAS13
Definition: GMcache.h:976
GMcache::CMS8_pp_phi_Zga_llga
gslpp::matrix< double > CMS8_pp_phi_Zga_llga
Definition: GMcache.h:130
GMcache::CMS13_pp_phi_hh_bbbb_2
gslpp::matrix< double > CMS13_pp_phi_hh_bbbb_2
Definition: GMcache.h:130
GMcache::THoEX_VV_H5ppmm_WW_jjll_CMS8
double THoEX_VV_H5ppmm_WW_jjll_CMS8
Definition: GMcache.h:990
GMcache::ATLAS13_pp_H5ppmmH5mmpp_llll
gslpp::matrix< double > ATLAS13_pp_H5ppmmH5mmpp_llll
Definition: GMcache.h:130
GMcache::GammaAtotSM
double GammaAtotSM
Definition: GMcache.h:1410
GMcache::ATLAS13_pp_phi_gaga
gslpp::matrix< double > ATLAS13_pp_phi_gaga
Definition: GMcache.h:130
GMcache::Br_H5toWW
double Br_H5toWW
Definition: GMcache.h:940
GMcache::THoEX_pp_H_hh_bbtautau_2_CMS13
double THoEX_pp_H_hh_bbtautau_2_CMS13
Definition: GMcache.h:973
GMcache::ATLAS13_gg_phi_WW_lnuqq
gslpp::matrix< double > ATLAS13_gg_phi_WW_lnuqq
Definition: GMcache.h:130
GMcache::pp_H_hh_bbbb_TH13
double pp_H_hh_bbbb_TH13
Cross section times branching ratio for the process at the LHC with 13 TeV.
Definition: GMcache.h:1059
GMcache::SigmaHpp58
double SigmaHpp58
Definition: GMcache.h:1392
GMcache::pp_H5_Zga_llga_TH8
double pp_H5_Zga_llga_TH8
Definition: GMcache.h:1045
GMcache::ATLAS8_gg_phi_WW
gslpp::matrix< double > ATLAS8_gg_phi_WW
Definition: GMcache.h:130
GMcache::ip_cs_VBFH5m_8
double ip_cs_VBFH5m_8(double mass)
Definition: GMcache.cpp:1105
GMcache::pp_Hpm_tb_TH8
double pp_Hpm_tb_TH8
Definition: GMcache.h:1067
StandardModel::computeBrHtotautau
double computeBrHtotautau() const
The Br in the Standard Model.
Definition: StandardModel.h:2264
GMcache::CMS13_gg_phi_hh_bbbb
gslpp::matrix< double > CMS13_gg_phi_hh_bbbb
Definition: GMcache.h:130
GMcache::gHH3pH3m
double gHH3pH3m
Definition: GMcache.h:1005
GMcache::ip_ex_pp_phi_hh_bbbb_CMS8
double ip_ex_pp_phi_hh_bbbb_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1959
GMcache::ip_ex_gg_phi_hh_bbtautau_CMS8_cache
double ip_ex_gg_phi_hh_bbtautau_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1530
GMcache::log_cs_WH_13
gslpp::matrix< double > log_cs_WH_13
Definition: GMcache.h:79
GMcache::THoEX_gg_A_Zga_qqga_ATLAS13
double THoEX_gg_A_Zga_qqga_ATLAS13
Definition: GMcache.h:956
GMcache::ip_ex_gg_phi_tautau_CMS13_cache
double ip_ex_gg_phi_tautau_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1497
GMcache::ATLAS13_WZ_H5pm_WZ_lnull_e
gslpp::matrix< double > ATLAS13_WZ_H5pm_WZ_lnull_e
Expected upper cross section limits, depending on the invariant mass.
Definition: GMcache.h:156
GMcache::br_aa
gslpp::matrix< double > br_aa
SM Higgs branching ratio tables (obtained with HDECAY 6.10), depending on the Higgs mass.
Definition: GMcache.h:64
GMcache::ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13_cache
double ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1573
GMcache::gg_A_Zga_TH13
double gg_A_Zga_TH13
Definition: GMcache.h:1044
GMcache::log_cs_ttA_13
gslpp::matrix< double > log_cs_ttA_13
Definition: GMcache.h:109
GMcache::THoEX_gg_A_hZ_bbZ_2_CMS13
double THoEX_gg_A_hZ_bbZ_2_CMS13
Definition: GMcache.h:980
GMcache::I_A_U
gslpp::complex I_A_U(const double mA2, const double Mc, const double Mt) const
Definition: GMcache.cpp:2762
GMcache::THoEX_gg_A_hZ_tautaull_CMS8
double THoEX_gg_A_hZ_tautaull_CMS8
Definition: GMcache.h:978
GMcache::THoEX_gg_H_tautau_CMS13
double THoEX_gg_H_tautau_CMS13
Definition: GMcache.h:949
GMcache::pp_A_HZ_bbll_TH8
double pp_A_HZ_bbll_TH8
Definition: GMcache.h:1064
GMcache::CMS8_gg_phi_bb
gslpp::matrix< double > CMS8_gg_phi_bb
Definition: GMcache.h:130
GMcache::pp_Hpm_tb_TH13
double pp_Hpm_tb_TH13
Definition: GMcache.h:1067
GMcache::ip_ex_pp_Hpm_tb_ATLAS8
double ip_ex_pp_Hpm_tb_ATLAS8(double mHp)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2421
GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS13_cache
double ip_ex_VV_H5ppmm_WW_jjll_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1575
GMcache::ip_ex_VV_phi_ZZ_llqqnunull_CMS13_cache
double ip_ex_VV_phi_ZZ_llqqnunull_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1515
GMcache::CMS13_pp_phi_hh_gagabb
gslpp::matrix< double > CMS13_pp_phi_hh_gagabb
Definition: GMcache.h:130
GMcache::A_h_D
gslpp::complex A_h_D(const double mHl2, const double cW2, const double Md, const double Ms, const double Mb, const double MZ) const
Definition: GMcache.cpp:2972
GMcache::ip_ex_gg_A_hZ_bbll_CMS8_cache
double ip_ex_gg_A_hZ_bbll_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1544
GMcache::THoEX_gg_H_hh_gagaWW_ATLAS13
double THoEX_gg_H_hh_gagaWW_ATLAS13
Definition: GMcache.h:973
GMcache::ip_ex_pp_phi_Zga_llga_CMS8
double ip_ex_pp_phi_Zga_llga_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1623
GMcache::Br_AtoH5pW
double Br_AtoH5pW
Definition: GMcache.h:938
GMcache::ip_ex_bb_phi_tt_ATLAS13_cache
double ip_ex_bb_phi_tt_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1487
GMcache::ip_ex_gg_A_hZ_bbZ_2_CMS13
double ip_ex_gg_A_hZ_bbZ_2_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2281
GMcache::log_cs_VHH5_13
gslpp::matrix< double > log_cs_VHH5_13
Definition: GMcache.h:124
GMcache::interpolate2D
double interpolate2D(gslpp::matrix< double > &arrayTab, double x, double y)
Linearly interpolates a table with two parameter dimensions.
Definition: GMcache.cpp:2694
GMcache::ip_ex_pp_Hp_tb_CMS8
double ip_ex_pp_Hp_tb_CMS8(double mHp)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2435
GMcache::pp_H_VV_TH13
double pp_H_VV_TH13
Definition: GMcache.h:1050
GMcache::ip_cs_pptottH_13_cache
double ip_cs_pptottH_13_cache[2][CacheSize]
Definition: GMcache.h:1457
GMcache::CacheSize
static const int CacheSize
Cache size.
Definition: GMcache.h:1119
GMcache::ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8
double ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2533
GMcache::THoEX_gg_H_WW_ATLAS8
double THoEX_gg_H_WW_ATLAS8
Definition: GMcache.h:964
GMcache::ip_Br_HPtotautau_cache
double ip_Br_HPtotautau_cache[2][CacheSize]
Definition: GMcache.h:1442
GMcache::ip_ex_gg_phi_tautau_CMS13
double ip_ex_gg_phi_tautau_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1525
GMcache::SigmaHpp513
double SigmaHpp513
Definition: GMcache.h:1392
GMcache::log_cs_ggHp_13
gslpp::matrix< double > log_cs_ggHp_13
Charged Higgs production cross section table at 13 TeV from LHCHXSWGMSSMCharged, depending on the cha...
Definition: GMcache.h:119
GMcache::A_A_D_cache
gslpp::complex A_A_D_cache[6][CacheSize]
Definition: GMcache.h:1190
GMcache::ip_ex_bb_phi_tautau_ATLAS8
double ip_ex_bb_phi_tautau_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a bottom quark produced scalar resonance...
Definition: GMcache.cpp:1483
GMcache::ip_ex_pp_Hpm_taunu_ATLAS8
double ip_ex_pp_Hpm_taunu_ATLAS8(double mHp)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2365
GMcache::ip_ex_pp_phi_hh_bbtautau_1_CMS13
double ip_ex_pp_phi_hh_bbtautau_1_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2113
GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS8_cache
double ip_ex_VV_H5ppmm_WW_jjll_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1574
GMcache::THoEX_pp_H5_hh_bbtautau_CMS13
double THoEX_pp_H5_hh_bbtautau_CMS13
Definition: GMcache.h:977
GMcache::rHH_gg
double rHH_gg
Definition: GMcache.h:934
GMcache::pp_H_bb_TH13
double pp_H_bb_TH13
Definition: GMcache.h:1023
GMcache::Br_Htotautau
double Br_Htotautau
Definition: GMcache.h:936
GMcache::THoEX_VV_H_ZZ_llqqnunull_CMS13
double THoEX_VV_H_ZZ_llqqnunull_CMS13
Definition: GMcache.h:960
StandardModel::getAlsMz
double getAlsMz() const
A get method to access the value of .
Definition: StandardModel.h:727
GMcache::CMS13_gg_phi_gaga
gslpp::matrix< double > CMS13_gg_phi_gaga
Definition: GMcache.h:130
GMcache::Br_H5pptoWW
double Br_H5pptoWW
Definition: GMcache.h:943
GMcache::ip_cs_VBFH5mm_8_cache
double ip_cs_VBFH5mm_8_cache[2][CacheSize]
Definition: GMcache.h:1474
GMcache::ip_ex_gg_phi_WW_ATLAS8_cache
double ip_ex_gg_phi_WW_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1517
GMcache::Br_HptohW
double Br_HptohW
Definition: GMcache.h:939
GMcache::br_WW
gslpp::matrix< double > br_WW
Definition: GMcache.h:64
GMcache::log_cs_VBFH5mm_8
gslpp::matrix< double > log_cs_VBFH5mm_8
Definition: GMcache.h:122
GMcache::THoEX_bb_H_bb_CMS8
double THoEX_bb_H_bb_CMS8
Definition: GMcache.h:946
GMcache::THoEX_pp_H_hh_gagabb_CMS8
double THoEX_pp_H_hh_gagabb_CMS8
Definition: GMcache.h:970
GMcache::THoEX_mu_pp_H_VV_CMS8
double THoEX_mu_pp_H_VV_CMS8
Definition: GMcache.h:968
GMcache::ip_ex_pp_phi_hh_bbtautau_CMS8_cache
double ip_ex_pp_phi_hh_bbtautau_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1531
GMcache::THoEX_pp_H_ZZ_qqnunu_CMS13
double THoEX_pp_H_ZZ_qqnunu_CMS13
Definition: GMcache.h:960
GMcache::ATLAS8_gg_A_hZ_bbZ
gslpp::matrix< double > ATLAS8_gg_A_hZ_bbZ
Definition: GMcache.h:130
GMcache::ATLAS8_pp_H5ppmmH5mmpp_eeee
gslpp::matrix< double > ATLAS8_pp_H5ppmmH5mmpp_eeee
Definition: GMcache.h:130
GMcache::ATLAS13_gg_phi_ZZ_llllnunu
gslpp::matrix< double > ATLAS13_gg_phi_ZZ_llllnunu
Definition: GMcache.h:130
GMcache::ip_ex_bb_phi_bb_CMS8_cache
double ip_ex_bb_phi_bb_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1488
GMcache::Br_Htobb
double Br_Htobb
Definition: GMcache.h:936
GMcache::GM_Br_h_gaga
double GM_Br_h_gaga
Definition: GMcache.h:935
QCD::UP
Definition: QCD.h:324
GMcache::THoEX_bb_A_bb_CMS13
double THoEX_bb_A_bb_CMS13
Definition: GMcache.h:947
GMcache::ip_ex_gg_phi_tautau_ATLAS13_cache
double ip_ex_gg_phi_tautau_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1496
GMcache::ip_ex_gg_phi_hh_bbbb_CMS13
double ip_ex_gg_phi_hh_bbbb_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2057
GMcache::ip_ex_pp_phi_VV_qqqq_ATLAS13_cache
double ip_ex_pp_phi_VV_qqqq_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1526
GMcache::THoEX_pp_A_Zga_llga_ATLAS8
double THoEX_pp_A_Zga_llga_ATLAS8
Definition: GMcache.h:956
GMcache::THoEX_pp_H5_VV_qqqq_ATLAS13
double THoEX_pp_H5_VV_qqqq_ATLAS13
Definition: GMcache.h:969
GMcache::ATLAS13_WZ_H5pm_WZ_lnull
gslpp::matrix< double > ATLAS13_WZ_H5pm_WZ_lnull
Definition: GMcache.h:130
GeorgiMachacek::getMu2
double getMu2() const
A method to get the massive parameter of the scalar potential .
Definition: GeorgiMachacek.h:419
GMcache::KaellenFunction_cache
double KaellenFunction_cache[4][CacheSize]
Definition: GMcache.h:1576
GMcache::cW2GM
double cW2GM(const double c02) const
Definition: GMcache.cpp:4609
lambda3
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:428
GMcache::ip_ex_gg_phi_gaga_ATLAS8
double ip_ex_gg_phi_gaga_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1567
GMcache::CMS8_pp_phi_hh_gagabb
gslpp::matrix< double > CMS8_pp_phi_hh_gagabb
Definition: GMcache.h:130
GMcache::THoEX_pp_H5ppmmH5mmpp_WWWW_ATLAS13
double THoEX_pp_H5ppmmH5mmpp_WWWW_ATLAS13
Definition: GMcache.h:990
GMcache::ip_ex_gg_phi_WW_lnuqq_ATLAS13_cache
double ip_ex_gg_phi_WW_lnuqq_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1521
GMcache::THoEX_tt_H_tt_ATLAS13
double THoEX_tt_H_tt_ATLAS13
Definition: GMcache.h:944
GMcache::A_HH_D
gslpp::complex A_HH_D(const double mHh2, const double cW2, const double Ms, const double Mb, const double MZ) const
Definition: GMcache.cpp:2994
GMcache::ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13
double ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1749
GMcache::GM_Br_h_WW
double GM_Br_h_WW
Definition: GMcache.h:935
GMcache::Br_HptoH5W
double Br_HptoH5W
Definition: GMcache.h:939
GMcache::Br_HtoH5pH5m
double Br_HtoH5pH5m
Definition: GMcache.h:936
gslpp.h
GMcache::ip_cs_pptobbH_8
double ip_cs_pptobbH_8(double mass)
Interpolating function for the bottom associated H production cross section at 8 TeV.
Definition: GMcache.cpp:839
GMcache::log_cs_VBFH5p_8
gslpp::matrix< double > log_cs_VBFH5p_8
Definition: GMcache.h:123
GMcache::ATLAS13_pp_Hpm_tb
gslpp::matrix< double > ATLAS13_pp_Hpm_tb
Definition: GMcache.h:130
GMcache::VV_H5_ZZ_TH8
double VV_H5_ZZ_TH8
Definition: GMcache.h:1047
GMcache::THoEX_WZ_H5pm_WZ_qqll_ATLAS8
double THoEX_WZ_H5pm_WZ_qqll_ATLAS8
Definition: GMcache.h:988
GMcache::ip_cs_pptottH_13
double ip_cs_pptottH_13(double mass)
Interpolating function for the top associated H production cross section at 13 TeV.
Definition: GMcache.cpp:820
GMcache::ip_ex_gg_phi_tautau_ATLAS13
double ip_ex_gg_phi_tautau_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1511
GeorgiMachacek::getcosa
double getcosa() const
A method to get .
Definition: GeorgiMachacek.h:226
GMcache::THoEX_pp_H_Zga_llga_ATLAS8
double THoEX_pp_H_Zga_llga_ATLAS8
Definition: GMcache.h:955
GMcache::ip_cs_ggtoH_8
double ip_cs_ggtoH_8(double mass)
Interpolating function for the H production cross section via gluon-gluon fusion at 8 TeV.
Definition: GMcache.cpp:649
GMcache::A_A_L
gslpp::complex A_A_L(const double mA2, const double cW2, const double Mmu, const double Mtau, const double MZ) const
Definition: GMcache.cpp:3076
GMcache::gHH5H5
double gHH5H5
Definition: GMcache.h:1007
GMcache::ip_Br_HPtoWW_cache
double ip_Br_HPtoWW_cache[2][CacheSize]
Definition: GMcache.h:1446
QCD::CHARM
Definition: QCD.h:326
GMcache::CMS13_bb_phi_bb
gslpp::matrix< double > CMS13_bb_phi_bb
Definition: GMcache.h:130
GMcache::ip_cs_ggtoA_13
double ip_cs_ggtoA_13(double mass)
Interpolating function for the A production cross section via gluon-gluon fusion at 13 TeV.
Definition: GMcache.cpp:896
GMcache::ip_cs_VBFH5mm_13
double ip_cs_VBFH5mm_13(double mass)
Definition: GMcache.cpp:1162
GMcache::ip_cs_pptottH_8
double ip_cs_pptottH_8(double mass)
Interpolating function for the top associated H production cross section at 8 TeV.
Definition: GMcache.cpp:801
GMcache::log_cs_ggA_8
gslpp::matrix< double > log_cs_ggA_8
CP-odd Higgs production cross section tables at 8 TeV obtained with HIGLU 4.34, depending on the Higg...
Definition: GMcache.h:104
GMcache::SigmabbF_H13
double SigmabbF_H13
Definition: GMcache.h:1386
GMcache::ATLAS8_VV_phi_ZZ
gslpp::matrix< double > ATLAS8_VV_phi_ZZ
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_gaga_ATLAS13_cache
double ip_ex_pp_phi_gaga_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1501
GMcache::THoEX_VV_H5_WW_ATLAS8
double THoEX_VV_H5_WW_ATLAS8
Definition: GMcache.h:966
GMcache::log_cs_VHH5mm_13
gslpp::matrix< double > log_cs_VHH5mm_13
Definition: GMcache.h:125
GMcache::Q_GM
double Q_GM
Definition: GMcache.h:1413
GMcache::THoEX_gg_H_gaga_CMS13
double THoEX_gg_H_gaga_CMS13
Definition: GMcache.h:952
StandardModel::computeBrHtobb
double computeBrHtobb() const
The Br in the Standard Model.
Definition: StandardModel.h:2299
GMcache::GammaHtotSM
double GammaHtotSM
Definition: GMcache.h:1409
GMcache::Int2
gslpp::complex Int2(const double tau, const double lambda) const
Definition: GMcache.cpp:3158
GMcache::THoEX_pp_H5_WW_lnuqq_CMS13
double THoEX_pp_H5_WW_lnuqq_CMS13
Definition: GMcache.h:967
GMcache::ip_cs_VBFH5_8_cache
double ip_cs_VBFH5_8_cache[2][CacheSize]
Definition: GMcache.h:1470
GMcache::ip_cs_VHH5mm_8
double ip_cs_VHH5mm_8(double mass)
Definition: GMcache.cpp:1295
GMcache::ip_ex_pp_Hpm_taunu_ATLAS13_cache
double ip_ex_pp_Hpm_taunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1559
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
GMcache::ip_ex_pp_phi_hh_bbtautau_ATLAS13
double ip_ex_pp_phi_hh_bbtautau_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2099
GMcache::CMS8_pp_Hp_tb
gslpp::matrix< double > CMS8_pp_Hp_tb
Definition: GMcache.h:130
GMcache::THoEX_bb_A_tautau_ATLAS8
double THoEX_bb_A_tautau_ATLAS8
Definition: GMcache.h:950
GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13
double ip_ex_WZ_H5pm_WZ_lnull_ATLAS13(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2463
GMcache::I_HH_D_cache
gslpp::complex I_HH_D_cache[4][CacheSize]
Definition: GMcache.h:1177
GMcache::A_A_D
gslpp::complex A_A_D(const double mA2, const double cW2, const double Ms, const double Mb, const double MZ) const
Definition: GMcache.cpp:3014
GMcache::THoEX_bb_A_tt_ATLAS13
double THoEX_bb_A_tt_ATLAS13
Definition: GMcache.h:945
GMcache::ip_ex_pp_phi_ZZ_qqnunu_CMS13_cache
double ip_ex_pp_phi_ZZ_qqnunu_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1516
GMcache::GM_Br_h_bb
double GM_Br_h_bb
Definition: GMcache.h:935
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
GMcache::ip_ex_gg_phi_Zga_CMS13
double ip_ex_gg_phi_Zga_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1665
GMcache::gg_A_gaga_TH8
double gg_A_gaga_TH8
Definition: GMcache.h:1041
GMcache::THoEX_pp_H_hh_gagabb_ATLAS13
double THoEX_pp_H_hh_gagabb_ATLAS13
Definition: GMcache.h:972
GMcache::Br_H5pptoHpHp
double Br_H5pptoHpHp
Definition: GMcache.h:943
GMcache::log_cs_VHH5pp_8
gslpp::matrix< double > log_cs_VHH5pp_8
Definition: GMcache.h:125
GMcache::ip_ex_bb_A_hZ_bbZ_ATLAS13_cache
double ip_ex_bb_A_hZ_bbZ_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1548
GMcache::THoEX_gg_A_tautau_CMS8
double THoEX_gg_A_tautau_CMS8
Definition: GMcache.h:950
GMcache::gH3H3pH5m
gslpp::complex gH3H3pH5m
Definition: GMcache.h:1014
GMcache::Br_HtoH5ppH5mm
double Br_HtoH5ppH5mm
Definition: GMcache.h:936
GMcache::Br_H5toZZ
double Br_H5toZZ
Definition: GMcache.h:940
GMcache::SigmaggF_H8
double SigmaggF_H8
Definition: GMcache.h:1373
GMcache::ATLAS13_gg_phi_Zga_llga
gslpp::matrix< double > ATLAS13_gg_phi_Zga_llga
Definition: GMcache.h:130
GMcache::ip_cs_ZtoZH_13
double ip_cs_ZtoZH_13(double mass)
Interpolating function for the Z associated H production cross section at 13 TeV.
Definition: GMcache.cpp:782
GMcache::ip_ex_pp_Hpm_tb_ATLAS13_cache
double ip_ex_pp_Hpm_tb_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1563
GMcache::ip_cs_ggtoH_8_cache
double ip_cs_ggtoH_8_cache[2][CacheSize]
Definition: GMcache.h:1448
GMcache::ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8
double ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2561
GMcache::ip_ex_gg_phi_Zga_CMS13_cache
double ip_ex_gg_phi_Zga_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1507
GMcache::rh_gg
double rh_gg
Definition: GMcache.h:933
GMcache::ip_ex_WZ_H5pm_WZ_lnull_1_CMS13_cache
double ip_ex_WZ_H5pm_WZ_lnull_1_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1567
GMcache::I_h_U
gslpp::complex I_h_U(const double mHl2, const double Mu, const double Mc, const double Mt) const
Definition: GMcache.cpp:2727
GMcache::CMS13_WZ_H5pm_WZ_lnull_1
gslpp::matrix< double > CMS13_WZ_H5pm_WZ_lnull_1
Definition: GMcache.h:130
QCD::ELECTRON
Definition: QCD.h:312
GMcache::A_H_Hp
gslpp::complex A_H_Hp(const double mHp2, const double mH, const double cW2, const double MZ) const
Definition: GMcache.cpp:3113
GMcache::ip_cs_ggtoHp_8
double ip_cs_ggtoHp_8(double mHp, double logtb)
Interpolating function for the H+ production cross section from two gluons at 8 TeV.
Definition: GMcache.cpp:991
GMcache::bb_A_tt_TH13
double bb_A_tt_TH13
Definition: GMcache.h:1022
GMcache::Br_HtoHpHm
double Br_HtoHpHm
Definition: GMcache.h:936
GMcache::computeUnitarity
void computeUnitarity()
Definition: GMcache.cpp:4479
GMcache::I_HH_L_cache
gslpp::complex I_HH_L_cache[4][CacheSize]
Definition: GMcache.h:1180
GMcache::ip_ex_gg_phi_tautau_ATLAS8_cache
double ip_ex_gg_phi_tautau_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1492
GMcache::SigmaggF_A8
double SigmaggF_A8
Definition: GMcache.h:1374
GMcache::ip_ex_bb_A_phiZ_bbll_ATLAS13_cache
double ip_ex_bb_A_phiZ_bbll_ATLAS13_cache[3][CacheSize]
Definition: GMcache.h:1556
gslpp::complex::abs2
double abs2() const
Definition: gslpp_complex.cpp:86
GMcache::ip_cs_WtoWH_8_cache
double ip_cs_WtoWH_8_cache[2][CacheSize]
Definition: GMcache.h:1452
GMcache::ip_cs_VBFtoH_13_cache
double ip_cs_VBFtoH_13_cache[2][CacheSize]
Definition: GMcache.h:1451
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:474
GeorgiMachacek::getmAsq
double getmAsq() const
A method to get the squared triplet mass.
Definition: GeorgiMachacek.h:343
GMcache::THoEX_gg_H_tautau_ATLAS8
double THoEX_gg_H_tautau_ATLAS8
Definition: GMcache.h:948
GMcache::Br_Atobb
double Br_Atobb
Definition: GMcache.h:938
GMcache::ip_ex_pp_phi_Zga_llga_CMS8_cache
double ip_ex_pp_phi_Zga_llga_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1504
GMcache::THoEX_gg_A_bb_CMS8
double THoEX_gg_A_bb_CMS8
Definition: GMcache.h:947
GMcache::ghHH
double ghHH
Definition: GMcache.h:1000
GMcache::Br_Hptotaunu
double Br_Hptotaunu
Definition: GMcache.h:939
GMcache::SigmaVBF_H8
double SigmaVBF_H8
Definition: GMcache.h:1377
GMcache::ip_ex_gg_A_hZ_tautaull_CMS8_cache
double ip_ex_gg_A_hZ_tautaull_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1546
GMcache::mu_pp_H5_VV_TH8
double mu_pp_H5_VV_TH8
Definition: GMcache.h:1051
GMcache::ip_ex_VV_phi_ZZ_llllnunu_ATLAS13
double ip_ex_VV_phi_ZZ_llllnunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1721
GMcache::~GMcache
~GMcache()
GMcache destructor.
Definition: GMcache.cpp:161
GMcache::THoEX_pp_A_Zga_llga_CMS8
double THoEX_pp_A_Zga_llga_CMS8
Definition: GMcache.h:956
GMcache::ip_ex_bb_A_hZ_bbZ_1_CMS13_cache
double ip_ex_bb_A_hZ_bbZ_1_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1550
GMcache::ATLAS13_gg_phi_hh_gagaWW
gslpp::matrix< double > ATLAS13_gg_phi_hh_gagaWW
Definition: GMcache.h:130
GMcache::mu_pp_H_VV_TH8
double mu_pp_H_VV_TH8
Definition: GMcache.h:1050
GMcache::ip_ex_pp_phi_hh_bbbb_CMS8_cache
double ip_ex_pp_phi_hh_bbbb_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1528
GMcache::bb_A_bb_TH8
double bb_A_bb_TH8
Definition: GMcache.h:1024
GMcache::THoEX_gg_A_hZ_bbZ_ATLAS13
double THoEX_gg_A_hZ_bbZ_ATLAS13
Definition: GMcache.h:979
GMcache::ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8_cache
double ip_ex_pp_H5ppmmH5mmpp_eeee_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1569
GMcache::ip_ex_gg_phi_bb_CMS8
double ip_ex_gg_phi_bb_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1413
GMcache::ip_ex_pp_phi_hh_bbtautau_2_CMS13_cache
double ip_ex_pp_phi_hh_bbtautau_2_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1540
GMcache::A_A_U_cache
gslpp::complex A_A_U_cache[6][CacheSize]
Definition: GMcache.h:1187
GMcache::THoEX_pp_H5ppmmH5mmpp_mumumumu_ATLAS8
double THoEX_pp_H5ppmmH5mmpp_mumumumu_ATLAS8
Definition: GMcache.h:989
GMcache::ip_ex_pp_phi_bb_CMS13
double ip_ex_pp_phi_bb_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1427
GMcache::pp_H_hh_bblnulnu_TH13
double pp_H_hh_bblnulnu_TH13
Definition: GMcache.h:1061
GMcache::THoEX_pp_H_Zga_llga_CMS8
double THoEX_pp_H_Zga_llga_CMS8
Definition: GMcache.h:955
GMcache::ATLAS13_VV_phi_ZZ_llllnunu
gslpp::matrix< double > ATLAS13_VV_phi_ZZ_llllnunu
Definition: GMcache.h:130
GMcache::ip_ex_gg_phi_Zga_qqga_ATLAS13
double ip_ex_gg_phi_Zga_qqga_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1651
GMcache::R_WZ_H5pm_WZ_lnull_ATLAS13
double R_WZ_H5pm_WZ_lnull_ATLAS13
Definition: GMcache.h:992
GMcache::SigmaggF_A13
double SigmaggF_A13
Definition: GMcache.h:1383
GMcache::br_tautau
gslpp::matrix< double > br_tautau
Definition: GMcache.h:64
GMcache::THoEX_pp_H5_gaga_ATLAS13
double THoEX_pp_H5_gaga_ATLAS13
Definition: GMcache.h:954
GMcache::ip_ex_WZ_H5pm_WZ_qqll_ATLAS8_cache
double ip_ex_WZ_H5pm_WZ_qqll_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1564
GMcache::ATLAS8_pp_H5ppmmH5mmpp_mumumumu
gslpp::matrix< double > ATLAS8_pp_H5ppmmH5mmpp_mumumumu
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_hh_bbtautau_1_CMS13_cache
double ip_ex_pp_phi_hh_bbtautau_1_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1539
GMcache::SigmaHp13
double SigmaHp13
Definition: GMcache.h:1392
GMcache::GF
double GF
Definition: GMcache.h:1414
GMcache::read
void read()
Fills all required arrays with the values read from the tables.
Definition: GMcache.cpp:220
GMcache::I_HH_U_cache
gslpp::complex I_HH_U_cache[4][CacheSize]
Definition: GMcache.h:1174
GMcache::log_cs_ttH_8
gslpp::matrix< double > log_cs_ttH_8
SM Higgs production cross section table at 8 TeV obtained with MadGraph 5, depending on the Higgs mas...
Definition: GMcache.h:84
GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e_cache
double ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e_cache[2][CacheSize]
Definition: GMcache.h:1566
GMcache::THoEX_gg_A_Zga_CMS13
double THoEX_gg_A_Zga_CMS13
Definition: GMcache.h:956
GMcache::SigmabbF_A13
double SigmabbF_A13
Definition: GMcache.h:1387
GMcache::ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13
double ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1735
GMcache::log_cs_VBFH5pp_13
gslpp::matrix< double > log_cs_VBFH5pp_13
Definition: GMcache.h:123
GMcache::SigmaTotSM_H8
double SigmaTotSM_H8
Definition: GMcache.h:1371
GMcache::ATLAS13_VV_phi_ZZ_qqllnunu
gslpp::matrix< double > ATLAS13_VV_phi_ZZ_qqllnunu
Definition: GMcache.h:130
GMcache::CMS13_pp_phi_hh_bblnulnu
gslpp::matrix< double > CMS13_pp_phi_hh_bblnulnu
Definition: GMcache.h:130
GMcache::ip_cs_VHH5pp_8
double ip_cs_VHH5pp_8(double mass)
Definition: GMcache.cpp:1333
GMcache::ATLAS13_gg_phi_WW_enumunu
gslpp::matrix< double > ATLAS13_gg_phi_WW_enumunu
Definition: GMcache.h:130
GMcache::ip_cs_VBFH5pp_13_cache
double ip_cs_VBFH5pp_13_cache[2][CacheSize]
Definition: GMcache.h:1479
lambda1
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:382
GMcache::pp_H_AZ_bbll_TH8
double pp_H_AZ_bbll_TH8
Definition: GMcache.h:1064
GMcache::gg_A_HZ_bbZ_TH13
double gg_A_HZ_bbZ_TH13
Definition: GMcache.h:1065
GMcache::ATLAS13_VV_phi_WW_enumunu
gslpp::matrix< double > ATLAS13_VV_phi_WW_enumunu
Definition: GMcache.h:130
GMcache::ip_ex_bb_phi_tautau_ATLAS8_cache
double ip_ex_bb_phi_tautau_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1494
GMcache::HSTheta
double HSTheta(const double x) const
Heaviside function.
Definition: GMcache.cpp:3261
GMcache::CMS8_gg_A_hZ_tautaull
gslpp::matrix< double > CMS8_gg_A_hZ_tautaull
Definition: GMcache.h:130
GMcache::CMS8_bb_phi_bb
gslpp::matrix< double > CMS8_bb_phi_bb
Definition: GMcache.h:130
GMcache::ip_ex_ggVV_phi_WW_lnulnu_CMS13
double ip_ex_ggVV_phi_WW_lnulnu_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1889
GMcache::I_H_Hp
gslpp::complex I_H_Hp(const double mHp2, const double mH) const
Definition: GMcache.cpp:2896
GMcache::log_cs_WH_8
gslpp::matrix< double > log_cs_WH_8
Definition: GMcache.h:74
GMcache::THoEX_gg_A_Zga_llga_ATLAS13
double THoEX_gg_A_Zga_llga_ATLAS13
Definition: GMcache.h:956
GMcache::ATLAS8_pp_Hpm_taunu
gslpp::matrix< double > ATLAS8_pp_Hpm_taunu
Definition: GMcache.h:130
GMcache::THoEX_pp_A_H5Z_bbll_CMS8
double THoEX_pp_A_H5Z_bbll_CMS8
Definition: GMcache.h:981
GMcache::ip_cs_VHH5pp_13_cache
double ip_cs_VHH5pp_13_cache[2][CacheSize]
Definition: GMcache.h:1485
GMcache::THoEX_pp_H_hh_bbtautau_ATLAS13
double THoEX_pp_H_hh_bbtautau_ATLAS13
Definition: GMcache.h:973
GMcache::GammaH3ptot
double GammaH3ptot
Total decay width of the charged Higgs .
Definition: GMcache.h:1088
GMcache::THoEX_pp_Hp_taunu_CMS8
double THoEX_pp_Hp_taunu_CMS8
Definition: GMcache.h:984
GMcache::ip_ex_gg_phi_gaga_ATLAS8_cache
double ip_ex_gg_phi_gaga_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1500
GMcache::SigmaHppHmm513
double SigmaHppHmm513
Definition: GMcache.h:1392
GMcache::ip_cs_VHH5_13
double ip_cs_VHH5_13(double mass)
Definition: GMcache.cpp:1276
GMcache::pp_H5_VV_TH8
double pp_H5_VV_TH8
Definition: GMcache.h:1051
GMcache::Br_HtoHpW
double Br_HtoHpW
Definition: GMcache.h:936
GMcache::log_cs_VBF_13
gslpp::matrix< double > log_cs_VBF_13
Definition: GMcache.h:79
GMcache::KaellenFunction
double KaellenFunction(const double a2, const double b2, const double c2) const
Kaellen function.
Definition: GMcache.cpp:3267
GMcache::CMS13_gg_A_Zh_Zbb_1
gslpp::matrix< double > CMS13_gg_A_Zh_Zbb_1
Definition: GMcache.h:130
GMcache::gH5H5ppH5mm
double gH5H5ppH5mm
Definition: GMcache.h:1017
GMcache::SigmaTotSM_H58
double SigmaTotSM_H58
Definition: GMcache.h:1372
GMcache::tanb
double tanb
Definition: GMcache.h:995
GMcache::ip_cs_VBFH5p_8_cache
double ip_cs_VBFH5p_8_cache[2][CacheSize]
Definition: GMcache.h:1476
GMcache::THoEX_pp_H_hh_bbbb_CMS8
double THoEX_pp_H_hh_bbbb_CMS8
Definition: GMcache.h:970
GMcache::gHHH
double gHHH
Definition: GMcache.h:1001
StandardModel::computeBrHtoZZ
double computeBrHtoZZ() const
The Br in the Standard Model.
Definition: StandardModel.h:2208
GMcache::ip_ex_gg_A_hZ_tautauZ_ATLAS8_cache
double ip_ex_gg_A_hZ_tautauZ_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1545
GMcache::ip_cs_pptobbH_8_cache
double ip_cs_pptobbH_8_cache[2][CacheSize]
Definition: GMcache.h:1458
GMcache::CMS8_pp_Hp_taunu
gslpp::matrix< double > CMS8_pp_Hp_taunu
Definition: GMcache.h:130
GMcache::GammaH5pptot
double GammaH5pptot
Total decay width of the doubly charged Higgs .
Definition: GMcache.h:1106
GMcache::SigmaVBF_H513
double SigmaVBF_H513
Definition: GMcache.h:1389
GMcache::ip_ex_pp_Hpm_taunu_CMS13_cache
double ip_ex_pp_Hpm_taunu_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1560
StandardModel::c02
double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel.cpp:939
GMcache::ip_ex_gg_A_hZ_bbZ_2_CMS13_cache
double ip_ex_gg_A_hZ_bbZ_2_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1551
GMcache::THoEX_pp_Hpm_taunu_ATLAS8
double THoEX_pp_Hpm_taunu_ATLAS8
Definition: GMcache.h:984
GMcache::THoEX_gg_H_tautau_CMS8
double THoEX_gg_H_tautau_CMS8
Definition: GMcache.h:948
GMcache::ip_ex_tt_phi_tt_ATLAS13_cache
double ip_ex_tt_phi_tt_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1486
GMcache::ip_ex_pp_phi_hh_bbbb_ATLAS13
double ip_ex_pp_phi_hh_bbbb_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2015
GMcache::ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13_cache
double ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1572
GMcache::ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13_cache
double ip_ex_VV_phi_ZZ_qqllnunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1513
GMcache::log_cs_ggHp_8
gslpp::matrix< double > log_cs_ggHp_8
Charged Higgs production cross section table at 8 TeV from LHCHXSWGMSSMCharged, depending on the char...
Definition: GMcache.h:114
GMcache::THoEX_VV_H_WW_lnuqq_ATLAS13
double THoEX_VV_H_WW_lnuqq_ATLAS13
Definition: GMcache.h:965
GMcache::log_cs_VBFH5_8
gslpp::matrix< double > log_cs_VBFH5_8
Definition: GMcache.h:121
GMcache::pp_H_hh_bbbb_TH8
double pp_H_hh_bbbb_TH8
Definition: GMcache.h:1052
GMcache::gH5H5H5
double gH5H5H5
Definition: GMcache.h:1013
GMcache::Br_HtoAZ
double Br_HtoAZ
Definition: GMcache.h:936
GMcache::ip_ex_bb_phi_tautau_CMS8
double ip_ex_bb_phi_tautau_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1497
GMcache::ghhh
double ghhh
Definition: GMcache.h:998
GMcache::ip_cs_pptobbA_13_cache
double ip_cs_pptobbA_13_cache[2][CacheSize]
Definition: GMcache.h:1465
GMcache::ip_ex_gg_A_hZ_tautaull_CMS8
double ip_ex_gg_A_hZ_tautaull_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2211
GMcache::THoEX_pp_H5_hh_bbbb_ATLAS13
double THoEX_pp_H5_hh_bbbb_ATLAS13
Definition: GMcache.h:975
GeorgiMachacek
A base class for the GeorgiMachacek model.
Definition: GeorgiMachacek.h:120
lambda4
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:451
GMcache::ATLAS13_bb_A_phiZ_bbll
gslpp::matrix< double > ATLAS13_bb_A_phiZ_bbll
Definition: GMcache.h:130
GeorgiMachacek::getMu1
double getMu1() const
A method to get the massive parameter of the scalar potential .
Definition: GeorgiMachacek.h:411
GMcache::CacheShiftReal
void CacheShiftReal(double cache[][CacheSize], const int NumPar, const double params[], const double newResult) const
Adds a new result and its parameters into the cache.
Definition: GMcache.cpp:206
Particle::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
GMcache::THoEX_pp_Hp_tb_CMS8
double THoEX_pp_Hp_tb_CMS8
Definition: GMcache.h:986
GMcache::ip_ex_gg_phi_ZZ_ATLAS8_cache
double ip_ex_gg_phi_ZZ_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1508
GMcache::ip_ex_ggVV_phi_WW_lnulnu_CMS13_cache
double ip_ex_ggVV_phi_WW_lnulnu_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1523
GMcache::THoEX_ggVV_H5_WW_lnulnu_CMS13
double THoEX_ggVV_H5_WW_lnulnu_CMS13
Definition: GMcache.h:967
GMcache::pp_H5ppmmH5mmpp_TH8
double pp_H5ppmmH5mmpp_TH8
Definition: GMcache.h:1069
GMcache::I_A_U_cache
gslpp::complex I_A_U_cache[4][CacheSize]
Definition: GMcache.h:1175
GMcache::bb_A_hZ_bbZ_TH13
double bb_A_hZ_bbZ_TH13
Definition: GMcache.h:1063
GMcache::THoEX_pp_A_HZ_bbll_CMS8
double THoEX_pp_A_HZ_bbll_CMS8
Definition: GMcache.h:981
GMcache::SigmaVBF_H13
double SigmaVBF_H13
Definition: GMcache.h:1388
GMcache::ATLAS8_bb_phi_tautau
gslpp::matrix< double > ATLAS8_bb_phi_tautau
Definition: GMcache.h:130
GMcache::VV_H_WW_TH8
double VV_H_WW_TH8
Definition: GMcache.h:1048
GMcache::THoEX_pp_H5_hh_gagabb_CMS8
double THoEX_pp_H5_hh_gagabb_CMS8
Definition: GMcache.h:974
GMcache::ip_cs_pptobbA_8
double ip_cs_pptobbA_8(double mass)
Interpolating function for the bottom associated A production cross section at 8 TeV.
Definition: GMcache.cpp:953
GMcache::THoEX_pp_H_ZZ_llqqnunull_CMS13
double THoEX_pp_H_ZZ_llqqnunull_CMS13
Definition: GMcache.h:959
GMcache::SigmaSumH58
double SigmaSumH58
Definition: GMcache.h:1370
GMcache::gHH5ppH5mm
double gHH5ppH5mm
Definition: GMcache.h:1011
GMcache::ip_ex_pp_phi_VV_qqqq_ATLAS13
double ip_ex_pp_phi_VV_qqqq_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1931
GMcache::Br_H5ptoHpA
double Br_H5ptoHpA
Definition: GMcache.h:942
GMcache::ATLAS13_pp_phi_hh_gagabb
gslpp::matrix< double > ATLAS13_pp_phi_hh_gagabb
Definition: GMcache.h:130
GMcache::pp_Hp_tb_TH8
double pp_Hp_tb_TH8
Definition: GMcache.h:1067
GMcache::CMS8_VV_H5ppmm_WW_jjll
gslpp::matrix< double > CMS8_VV_H5ppmm_WW_jjll
Definition: GMcache.h:130
GMcache::ip_ex_gg_phi_WW_enumunu_ATLAS13
double ip_ex_gg_phi_WW_enumunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1833
GMcache::ATLAS13_bb_A_Zh_Zbb
gslpp::matrix< double > ATLAS13_bb_A_Zh_Zbb
Definition: GMcache.h:130
GMcache::ip_ex_VV_phi_WW_lnuqq_ATLAS13_cache
double ip_ex_VV_phi_WW_lnuqq_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1522
GMcache::A_h_U
gslpp::complex A_h_U(const double mHl2, const double cW2, const double Mu, const double Mc, const double Mt, const double MZ) const
Definition: GMcache.cpp:2911
GMcache::ip_Br_HPtobb
double ip_Br_HPtobb(double mass)
Interpolating function for the SM branching ratio to two bottom quarks.
Definition: GMcache.cpp:538
GMcache::computeSignalStrengthQuantities
void computeSignalStrengthQuantities()
Definition: GMcache.cpp:3162
GMcache::computeDirectSearchQuantities
void computeDirectSearchQuantities()
Definition: GMcache.cpp:3764
GMcache::ggVV_H_WW_lnulnu_TH13
double ggVV_H_WW_lnulnu_TH13
Definition: GMcache.h:1048
GMcache::ip_ex_VV_phi_ZZ_llqqnunull_CMS13
double ip_ex_VV_phi_ZZ_llqqnunull_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1777
GMcache::ATLAS8_gg_phi_ZZ
gslpp::matrix< double > ATLAS8_gg_phi_ZZ
Definition: GMcache.h:130
GMcache::ip_ex_gg_phi_WW_lnuqq_ATLAS13
double ip_ex_gg_phi_WW_lnuqq_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1861
GMcache::ip_cs_VBFH5_8
double ip_cs_VBFH5_8(double mass)
Definition: GMcache.cpp:1067
GMcache::ATLAS8_VV_phi_WW
gslpp::matrix< double > ATLAS8_VV_phi_WW
Definition: GMcache.h:130
GMcache::ip_cs_ggtoA_8
double ip_cs_ggtoA_8(double mass)
Interpolating function for the A production cross section via gluon-gluon fusion at 8 TeV.
Definition: GMcache.cpp:877
GMcache::ATLAS13_pp_phi_hh_bbtautau
gslpp::matrix< double > ATLAS13_pp_phi_hh_bbtautau
Definition: GMcache.h:130
GMcache::SigmaSumA8
double SigmaSumA8
Definition: GMcache.h:1369
GMcache::ip_ex_gg_phi_ZZ_llllnunu_ATLAS13
double ip_ex_gg_phi_ZZ_llllnunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1707
GMcache::CMS13_pp_Hpm_taunu
gslpp::matrix< double > CMS13_pp_Hpm_taunu
Definition: GMcache.h:130
GMcache::THoEX_gg_H_hh_bbtautau_CMS8
double THoEX_gg_H_hh_bbtautau_CMS8
Definition: GMcache.h:971
GMcache::ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8
double ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2547
QCD::TOP
Definition: QCD.h:328
GMcache::bb_A_bb_TH13
double bb_A_bb_TH13
Definition: GMcache.h:1024
GMcache::ip_cs_VHH5_13_cache
double ip_cs_VHH5_13_cache[2][CacheSize]
Definition: GMcache.h:1481
GMcache::pp_H_Zga_llga_TH8
double pp_H_Zga_llga_TH8
Definition: GMcache.h:1043
GMcache::ip_ex_VV_phi_WW_lnuqq_ATLAS13
double ip_ex_VV_phi_WW_lnuqq_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1875
GMcache::log_cs_ppH5ppH5mm_8
gslpp::matrix< double > log_cs_ppH5ppH5mm_8
Definition: GMcache.h:121
GMcache::pp_H5ppmmH5mmpp_WWWW_TH13
double pp_H5ppmmH5mmpp_WWWW_TH13
Definition: GMcache.h:1069
GMcache::ip_ex_VV_phi_WW_ATLAS8
double ip_ex_VV_phi_WW_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1819
GMcache::Br_H5pptoHpW
double Br_H5pptoHpW
Definition: GMcache.h:943
GMcache::I_HH_D
gslpp::complex I_HH_D(const double mHh2, const double Ms, const double Mb) const
Definition: GMcache.cpp:2796
GMcache::log_cs_bbA_13
gslpp::matrix< double > log_cs_bbA_13
Definition: GMcache.h:109
GMcache::ip_cs_ppH5ppH5mm_8_cache
double ip_cs_ppH5ppH5mm_8_cache[2][CacheSize]
Definition: GMcache.h:1468
GMcache::interpolate
double interpolate(gslpp::matrix< double > &arrayTab, double x)
Linearly interpolates a table with one parameter dimension.
Definition: GMcache.cpp:2667
GMcache::I_H_Hp_cache
gslpp::complex I_H_Hp_cache[3][CacheSize]
Definition: GMcache.h:1183
GMcache::ip_ex_pp_phi_Zga_llga_ATLAS8_cache
double ip_ex_pp_phi_Zga_llga_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1503
GMcache::ghH5H5
double ghH5H5
Definition: GMcache.h:1006
StandardModel::computeGammaHTotal
double computeGammaHTotal() const
The Higgs total width in the Standard Model.
Definition: StandardModel.h:2311
GMcache::A_HH_U
gslpp::complex A_HH_U(const double mHh2, const double cW2, const double Mc, const double Mt, const double MZ) const
Definition: GMcache.cpp:2933
GMcache::ip_ex_pp_phi_hh_bbbb_2_CMS13_cache
double ip_ex_pp_phi_hh_bbbb_2_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1534
GMcache::ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13
double ip_ex_pp_H5ppmmH5mmpp_WWWW_ATLAS13(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2589
GMcache::A_A_L_cache
gslpp::complex A_A_L_cache[6][CacheSize]
Definition: GMcache.h:1193
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
GMcache::VV_H_WW_TH13
double VV_H_WW_TH13
Definition: GMcache.h:1048
GMcache::SigmaVH_H513
double SigmaVH_H513
Definition: GMcache.h:1391
GMcache::SigmattF_H13
double SigmattF_H13
Definition: GMcache.h:1384
GMcache::ghH5ppH5mm
double ghH5ppH5mm
Definition: GMcache.h:1010
GMcache::THoEX_VV_H5_ZZ_llqqnunull_CMS13
double THoEX_VV_H5_ZZ_llqqnunull_CMS13
Definition: GMcache.h:963
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
GMcache::CMS13_pp_phi_ZZ_qqnunu
gslpp::matrix< double > CMS13_pp_phi_ZZ_qqnunu
Definition: GMcache.h:130
GMcache::CMS13_pp_phi_hh_bbbb_1
gslpp::matrix< double > CMS13_pp_phi_hh_bbbb_1
Definition: GMcache.h:130
GMcache::gg_A_hZ_tautauZ_TH8
double gg_A_hZ_tautauZ_TH8
Definition: GMcache.h:1063
GMcache::ip_ex_pp_phi_hh_gagabb_CMS13_cache
double ip_ex_pp_phi_hh_gagabb_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1537
GeorgiMachacek::getQ_GM
double getQ_GM() const
A method to get the Georgi-Machacek scale.
Definition: GeorgiMachacek.h:427
GMcache::ip_ex_pp_A_phiZ_bbll_CMS8
double ip_ex_pp_A_phiZ_bbll_CMS8(double mA, double mH)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2309
GMcache::GammaH5ptot
double GammaH5ptot
Total decay width of the charged Higgs .
Definition: GMcache.h:1100
GMcache::ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8_cache
double ip_ex_pp_H5ppmmH5mmpp_emuemu_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1570
GMcache::THoEX_gg_H_hh_ATLAS8
double THoEX_gg_H_hh_ATLAS8
Definition: GMcache.h:970
gslpp::complex::i
static const complex & i()
Definition: gslpp_complex.cpp:154
GMcache::ATLAS13_bb_phi_tt
gslpp::matrix< double > ATLAS13_bb_phi_tt
Definition: GMcache.h:130
GMcache::ip_ex_bb_phi_bb_CMS13
double ip_ex_bb_phi_bb_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1441
GMcache::br_cc
gslpp::matrix< double > br_cc
Definition: GMcache.h:64
GMcache::Br_Atogaga
double Br_Atogaga
Definition: GMcache.h:938
GMcache::A_h_D_cache
gslpp::complex A_h_D_cache[7][CacheSize]
Definition: GMcache.h:1188
GMcache::THoEX_pp_A_bb_CMS13
double THoEX_pp_A_bb_CMS13
Definition: GMcache.h:947
GMcache::A_HH_U_cache
gslpp::complex A_HH_U_cache[6][CacheSize]
Definition: GMcache.h:1186
GMcache::ATLAS13_pp_phi_hh_bbbb
gslpp::matrix< double > ATLAS13_pp_phi_hh_bbbb
Definition: GMcache.h:130
GMcache::I_h_U_cache
gslpp::complex I_h_U_cache[5][CacheSize]
Definition: GMcache.h:1173
StandardModel::computeBrHtoZga
double computeBrHtoZga() const
The Br in the Standard Model.
Definition: StandardModel.h:2230
GMcache::Br_H5ptoHpZ
double Br_H5ptoHpZ
Definition: GMcache.h:942
GMcache::ip_GammaHPtotSM
double ip_GammaHPtotSM(double mass)
Interpolating function for the total SM Higgs decay width.
Definition: GMcache.cpp:634
GMcache::ggVV_H5_WW_lnulnu_TH13
double ggVV_H5_WW_lnulnu_TH13
Definition: GMcache.h:1049
QCD::getMtpole
double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:588
GMcache::THoEX_gg_A_tautau_ATLAS13
double THoEX_gg_A_tautau_ATLAS13
Definition: GMcache.h:951
GMcache::THoEX_pp_H5_AZ_bbll_CMS8
double THoEX_pp_H5_AZ_bbll_CMS8
Definition: GMcache.h:983
GMcache::THoEX_gg_H_ZZ_qqllnunu_ATLAS13
double THoEX_gg_H_ZZ_qqllnunu_ATLAS13
Definition: GMcache.h:959
GMcache::rHH_ff
double rHH_ff
Definition: GMcache.h:934
GMcache::Br_HtoH5H5
double Br_HtoH5H5
Definition: GMcache.h:936
GMcache::ATLAS13_gg_phi_ZZ_qqllnunu
gslpp::matrix< double > ATLAS13_gg_phi_ZZ_qqllnunu
Definition: GMcache.h:130
GMcache::SigmabbF_H8
double SigmabbF_H8
Definition: GMcache.h:1375
GMcache::ip_cs_ppH5ppH5mm_13
double ip_cs_ppH5ppH5mm_13(double mass)
Definition: GMcache.cpp:1048
GMcache::ATLAS13_pp_phi_VV_qqqq
gslpp::matrix< double > ATLAS13_pp_phi_VV_qqqq
Definition: GMcache.h:130
StandardModel::computeBrHtogaga
double computeBrHtogaga() const
The Br in the Standard Model.
Definition: StandardModel.h:2242
GMcache::gg_H_ZZ_TH8
double gg_H_ZZ_TH8
Definition: GMcache.h:1046
GMcache::ip_cs_VHH5_8
double ip_cs_VHH5_8(double mass)
Definition: GMcache.cpp:1257
GMcache::ip_cs_ggtoHp_8_cache
double ip_cs_ggtoHp_8_cache[3][CacheSize]
Definition: GMcache.h:1466
GMcache::I_A_L
gslpp::complex I_A_L(const double mA2, const double Mmu, const double Mtau) const
Definition: GMcache.cpp:2865
GMcache::cosb
double cosb
Definition: GMcache.h:995
GMcache::gg_H_WW_TH13
double gg_H_WW_TH13
Definition: GMcache.h:1048
GMcache::pp_H_hh_gagabb_TH8
double pp_H_hh_gagabb_TH8
Definition: GMcache.h:1052
GMcache::ip_ex_WZ_H5pm_WZ_lnull_2_CMS13
double ip_ex_WZ_H5pm_WZ_lnull_2_CMS13(double mH5)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2519
GMcache::WZ_H5pm_WZ_TH8
double WZ_H5pm_WZ_TH8
Definition: GMcache.h:1068
GMcache::ip_cs_WtoWH_13_cache
double ip_cs_WtoWH_13_cache[2][CacheSize]
Definition: GMcache.h:1453
GMcache::log_cs_VHH5mm_8
gslpp::matrix< double > log_cs_VHH5mm_8
Definition: GMcache.h:125
GMcache::CMS13_WZ_H5pm_WZ_lnull_2
gslpp::matrix< double > CMS13_WZ_H5pm_WZ_lnull_2
Definition: GMcache.h:130
GMcache::A_HH_L
gslpp::complex A_HH_L(const double mHh2, const double cW2, const double Mmu, const double Mtau, const double MZ) const
Definition: GMcache.cpp:3056
GMcache::ip_cs_ggtoH_13_cache
double ip_cs_ggtoH_13_cache[2][CacheSize]
Definition: GMcache.h:1449
GMcache::ip_ex_bb_phi_bb_CMS13_cache
double ip_ex_bb_phi_bb_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1491
GMcache::log_cs_VBFH5p_13
gslpp::matrix< double > log_cs_VBFH5p_13
Definition: GMcache.h:123
GMcache::VV_H5_WW_TH8
double VV_H5_WW_TH8
Definition: GMcache.h:1049
GMcache::ip_ex_gg_phi_tautau_ATLAS8
double ip_ex_gg_phi_tautau_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a gluon-gluon produced scalar resonance ...
Definition: GMcache.cpp:1455
GMcache::ghH3H3
double ghH3H3
Definition: GMcache.h:1002
GMcache::ip_ex_gg_phi_gaga_CMS13_cache
double ip_ex_gg_phi_gaga_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1502
GMcache::pp_H_ZZ_TH13
double pp_H_ZZ_TH13
Definition: GMcache.h:1046
GMcache::ip_cs_ZtoZH_13_cache
double ip_cs_ZtoZH_13_cache[2][CacheSize]
Definition: GMcache.h:1455
GMcache::THoEX_pp_Hpm_tb_ATLAS8
double THoEX_pp_Hpm_tb_ATLAS8
Definition: GMcache.h:986
GMcache::ip_cs_VBFH5_13
double ip_cs_VBFH5_13(double mass)
Definition: GMcache.cpp:1086
GMcache::pp_H5_AZ_bbll_TH8
double pp_H5_AZ_bbll_TH8
Definition: GMcache.h:1064
GMcache::Br_AtoHZ
double Br_AtoHZ
Definition: GMcache.h:938
GMcache::gg_H_tautau_TH13
double gg_H_tautau_TH13
Definition: GMcache.h:1038
GMcache::gH5H3pH3m
double gH5H3pH3m
Definition: GMcache.h:1015
GMcache::MW
double MW
Definition: GMcache.h:1418
GMcache.h
GMcache::ip_ex_gg_phi_tautau_CMS8_cache
double ip_ex_gg_phi_tautau_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1493
GMcache::THoEX_pp_Hpm_taunu_ATLAS13
double THoEX_pp_Hpm_taunu_ATLAS13
Definition: GMcache.h:985
GMcache::ip_cs_ggtoHp_13_cache
double ip_cs_ggtoHp_13_cache[3][CacheSize]
Definition: GMcache.h:1467
GMcache::ip_ex_bb_phi_tt_ATLAS13
double ip_ex_bb_phi_tt_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1385
GMcache::ip_ex_gg_phi_ZZ_llllnunu_ATLAS13_cache
double ip_ex_gg_phi_ZZ_llllnunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1510
GeorgiMachacek::Mw
virtual double Mw() const
Definition: GeorgiMachacek.cpp:375
GMcache::SigmaSumH513
double SigmaSumH513
Definition: GMcache.h:1381
GMcache::SigmattF_A13
double SigmattF_A13
Definition: GMcache.h:1385
GMcache::ip_ex_gg_A_hZ_tautauZ_ATLAS8
double ip_ex_gg_A_hZ_tautauZ_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2197
GMcache::I_A_L_cache
gslpp::complex I_A_L_cache[4][CacheSize]
Definition: GMcache.h:1181
GMcache::Mu2
double Mu2
Definition: GMcache.h:1429
lambda2
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:405
GMcache::log_cs_ZH_8
gslpp::matrix< double > log_cs_ZH_8
Definition: GMcache.h:74
GMcache::bb_H_tautau_TH8
double bb_H_tautau_TH8
Cross section times branching ratio for the process at the LHC with 8 TeV.
Definition: GMcache.h:1036
GMcache::gg_H_Zga_TH13
double gg_H_Zga_TH13
Definition: GMcache.h:1043
GMcache::Br_H5toZga
double Br_H5toZga
Definition: GMcache.h:940
GMcache::THoEX_VV_H_WW_ATLAS8
double THoEX_VV_H_WW_ATLAS8
Definition: GMcache.h:964
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
GMcache::log_cs_VBFH5m_8
gslpp::matrix< double > log_cs_VBFH5m_8
Definition: GMcache.h:122
GMcache::THoEX_gg_H_ZZ_ATLAS8
double THoEX_gg_H_ZZ_ATLAS8
Definition: GMcache.h:958
GMcache::gg_H_gaga_TH8
double gg_H_gaga_TH8
Definition: GMcache.h:1040
GMcache::log_cs_ttH_13
gslpp::matrix< double > log_cs_ttH_13
SM Higgs production cross section table at 13 TeV obtained with MadGraph 5, depending on the Higgs ma...
Definition: GMcache.h:89
GMcache::ip_cs_pptobbH_13
double ip_cs_pptobbH_13(double mass)
Interpolating function for the bottom associated H production cross section at 13 TeV.
Definition: GMcache.cpp:858
GMcache::ip_ex_gg_phi_hh_bbtautau_CMS8
double ip_ex_gg_phi_hh_bbtautau_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1987
GMcache::ip_ex_pp_phi_AZ_bbll_CMS8_cache
double ip_ex_pp_phi_AZ_bbll_CMS8_cache[3][CacheSize]
Definition: GMcache.h:1554
GMcache::MZ
double MZ
Definition: GMcache.h:1416
GMcache::ip_Br_HPtoZZ
double ip_Br_HPtoZZ(double mass)
Interpolating function for the SM branching ratio to two bosons.
Definition: GMcache.cpp:602
GMcache::ip_cs_VHH5pp_13
double ip_cs_VHH5pp_13(double mass)
Definition: GMcache.cpp:1352
GMcache::CMS13_gg_phi_Zga
gslpp::matrix< double > CMS13_gg_phi_Zga
Definition: GMcache.h:130
gslpp::matrix< double >::size_i
size_t size_i() const
Definition: gslpp_matrix_double.cpp:132
GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS13
double ip_ex_gg_A_hZ_bbZ_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2225
GMcache::ip_ex_WZ_H5pm_WZ_lnull_2_CMS13_cache
double ip_ex_WZ_H5pm_WZ_lnull_2_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1568
GMcache::bb_A_HZ_bbZ_TH13
double bb_A_HZ_bbZ_TH13
Definition: GMcache.h:1065
GMcache::THoEX_bb_H_tautau_CMS13
double THoEX_bb_H_tautau_CMS13
Definition: GMcache.h:949
GMcache::ip_ex_bb_phi_tautau_CMS13
double ip_ex_bb_phi_tautau_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1553
GMcache::THoEX_mu_pp_H5_VV_CMS8
double THoEX_mu_pp_H5_VV_CMS8
Definition: GMcache.h:969
GMcache::ip_cs_ggtoA_8_cache
double ip_cs_ggtoA_8_cache[2][CacheSize]
Definition: GMcache.h:1460
GMcache::THoEX_gg_H_tautau_ATLAS13
double THoEX_gg_H_tautau_ATLAS13
Definition: GMcache.h:949
GMcache::log_cs_bbH_8
gslpp::matrix< double > log_cs_bbH_8
SM Higgs production cross section table at 8 TeV obtained with SusHi 1.5, depending on the Higgs mass...
Definition: GMcache.h:94
GMcache::THoEX_gg_H_Zga_qqga_ATLAS13
double THoEX_gg_H_Zga_qqga_ATLAS13
Definition: GMcache.h:955
GMcache::ATLAS8_gg_phi_hh
gslpp::matrix< double > ATLAS8_gg_phi_hh
Definition: GMcache.h:130
GMcache::ip_cs_pptobbA_8_cache
double ip_cs_pptobbA_8_cache[2][CacheSize]
Definition: GMcache.h:1464
GMcache::ip_cs_VBFH5pp_8
double ip_cs_VBFH5pp_8(double mass)
Definition: GMcache.cpp:1219
GMcache::THoEX_bb_A_tautau_CMS13
double THoEX_bb_A_tautau_CMS13
Definition: GMcache.h:951
GMcache::ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13_cache
double ip_ex_gg_phi_ZZ_qqllnunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1512
GMcache::log_cs_ttA_8
gslpp::matrix< double > log_cs_ttA_8
Definition: GMcache.h:104
GMcache::ip_ex_bb_phi_tautau_ATLAS13_cache
double ip_ex_bb_phi_tautau_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1498
GMcache::ATLAS13_tt_phi_tt
gslpp::matrix< double > ATLAS13_tt_phi_tt
Observed upper cross section limits, depending on the invariant mass.
Definition: GMcache.h:130
GMcache::ip_Br_HPtocc_cache
double ip_Br_HPtocc_cache[2][CacheSize]
Definition: GMcache.h:1443
GMcache::ip_ex_gg_phi_WW_enumunu_ATLAS13_cache
double ip_ex_gg_phi_WW_enumunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1519
GMcache::CMS13_VV_phi_ZZ_llqqnunull
gslpp::matrix< double > CMS13_VV_phi_ZZ_llqqnunull
Definition: GMcache.h:130
GMcache::CMS8_gg_A_hZ_bbll
gslpp::matrix< double > CMS8_gg_A_hZ_bbll
Definition: GMcache.h:130
GMcache::CMS8_gg_phi_hh_bbtautau
gslpp::matrix< double > CMS8_gg_phi_hh_bbtautau
Definition: GMcache.h:130
GMcache::M1sq
double M1sq
Definition: GMcache.h:1430
GMcache::ip_ex_gg_phi_hh_ATLAS8
double ip_ex_gg_phi_hh_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1945
GMcache::VV_H5ppmm_WW_TH13
double VV_H5ppmm_WW_TH13
Definition: GMcache.h:1070
GMcache::gg_A_gaga_TH13
double gg_A_gaga_TH13
Definition: GMcache.h:1041
GMcache::THoEX_pp_H_hh_gagabb_CMS13
double THoEX_pp_H_hh_gagabb_CMS13
Definition: GMcache.h:972
GMcache::SigmaHp58
double SigmaHp58
Definition: GMcache.h:1392
GMcache::ip_cs_pptottA_13_cache
double ip_cs_pptottA_13_cache[2][CacheSize]
Definition: GMcache.h:1463
GMcache::gg_A_hZ_bbll_TH8
double gg_A_hZ_bbll_TH8
Definition: GMcache.h:1063
GMcache::ip_ex_gg_phi_bb_CMS8_cache
double ip_ex_gg_phi_bb_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1489
GMcache::GM_Br_h_ZZ
double GM_Br_h_ZZ
Definition: GMcache.h:935
GMcache::br_mumu
gslpp::matrix< double > br_mumu
Definition: GMcache.h:64
GMcache::ip_ex_pp_phi_hh_bbbb_1_CMS13_cache
double ip_ex_pp_phi_hh_bbbb_1_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1533
GMcache::THoEX_gg_H_WW_lnuqq_ATLAS13
double THoEX_gg_H_WW_lnuqq_ATLAS13
Definition: GMcache.h:965
GMcache::ip_cs_pptobbH_13_cache
double ip_cs_pptobbH_13_cache[2][CacheSize]
Definition: GMcache.h:1459
GMcache::ip_ex_pp_phi_WW_lnuqq_CMS13
double ip_ex_pp_phi_WW_lnuqq_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1903
GMcache::log_cs_ggA_13
gslpp::matrix< double > log_cs_ggA_13
CP-odd Higgs production cross section tables at 13 TeV obtained with HIGLU 4.34, depending on the Hig...
Definition: GMcache.h:109
GMcache::ip_cs_VBFH5p_13_cache
double ip_cs_VBFH5p_13_cache[2][CacheSize]
Definition: GMcache.h:1477
GMcache::ip_ex_pp_Hpm_taunu_ATLAS13
double ip_ex_pp_Hpm_taunu_ATLAS13(double mHp)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2393
GMcache::VV_H5_WW_TH13
double VV_H5_WW_TH13
Definition: GMcache.h:1049
GMcache::THoEX_pp_H_hh_bblnulnu_CMS13
double THoEX_pp_H_hh_bblnulnu_CMS13
Definition: GMcache.h:973
GMcache::ATLAS8_pp_phi_Zga_llga
gslpp::matrix< double > ATLAS8_pp_phi_Zga_llga
Definition: GMcache.h:130
GMcache::pp_H_hh_bbtautau_TH13
double pp_H_hh_bbtautau_TH13
Definition: GMcache.h:1061
GMcache::THoEX_gg_A_gaga_CMS13
double THoEX_gg_A_gaga_CMS13
Definition: GMcache.h:953
GMcache::CMS8_bb_phi_tautau
gslpp::matrix< double > CMS8_bb_phi_tautau
Definition: GMcache.h:130
GMcache::br_tt
gslpp::matrix< double > br_tt
Definition: GMcache.h:64
GMcache::I_H_W_cache
gslpp::complex I_H_W_cache[3][CacheSize]
Definition: GMcache.h:1182
GMcache::BrRatioVV5
double BrRatioVV5
Definition: GMcache.h:941
GMcache::I_h_L
gslpp::complex I_h_L(const double mHl2, const double Me, const double Mmu, const double Mtau) const
Definition: GMcache.cpp:2829
GMcache::THoEX_VV_H_WW_enumunu_ATLAS13
double THoEX_VV_H_WW_enumunu_ATLAS13
Definition: GMcache.h:964
GMcache::THoEX_gg_H_Zga_CMS13
double THoEX_gg_H_Zga_CMS13
Definition: GMcache.h:955
GMcache::bb_A_tautau_TH13
double bb_A_tautau_TH13
Definition: GMcache.h:1039
GMcache::A_h_U_cache
gslpp::complex A_h_U_cache[7][CacheSize]
Definition: GMcache.h:1185
GMcache::THoEX_gg_H_gaga_ATLAS8
double THoEX_gg_H_gaga_ATLAS8
Definition: GMcache.h:952
GMcache::gg_H_hh_bbbb_TH13
double gg_H_hh_bbbb_TH13
Definition: GMcache.h:1061
GMcache::mAsq
double mAsq
Definition: GMcache.h:1426
GMcache::pp_A_H5Z_bbll_TH8
double pp_A_H5Z_bbll_TH8
Definition: GMcache.h:1064
GMcache::GammaH1tot
double GammaH1tot
Total decay width of the CP-even Higgs .
Definition: GMcache.h:1076
GMcache::ip_cs_VHH5pp_8_cache
double ip_cs_VHH5pp_8_cache[2][CacheSize]
Definition: GMcache.h:1484
GMcache::ip_ex_pp_phi_hh_bbbb_2_CMS13
double ip_ex_pp_phi_hh_bbbb_2_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance decaying to two bosons...
Definition: GMcache.cpp:2043
GMcache::THoEX_pp_H_hh_bbtautau_1_CMS13
double THoEX_pp_H_hh_bbtautau_1_CMS13
Definition: GMcache.h:973
GMcache::ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13
double ip_ex_pp_H5ppmmH5mmpp_llll_ATLAS13(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2575
GMcache::bb_A_tautau_TH8
double bb_A_tautau_TH8
Definition: GMcache.h:1039
GMcache::ip_ex_gg_phi_hh_ATLAS8_cache
double ip_ex_gg_phi_hh_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1527
GMcache::ip_cs_pptobbA_13
double ip_cs_pptobbA_13(double mass)
Interpolating function for the bottom associated A production cross section at 13 TeV.
Definition: GMcache.cpp:972
GeorgiMachacek::getvDelta
double getvDelta() const
A method to get .
Definition: GeorgiMachacek.h:210
GMcache::gg_A_tautau_TH13
double gg_A_tautau_TH13
Definition: GMcache.h:1039
GMcache::ip_ex_VV_phi_WW_enumunu_ATLAS13
double ip_ex_VV_phi_WW_enumunu_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1847
GMcache::sina
double sina
Definition: GMcache.h:1423
GMcache::log_cs_ggH_8
gslpp::matrix< double > log_cs_ggH_8
SM Higgs production cross section tables at 8 TeV from the LHC Higgs Cross Section Working Group,...
Definition: GMcache.h:74
GMcache::log_cs_VBF_8
gslpp::matrix< double > log_cs_VBF_8
Definition: GMcache.h:74
GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_cache
double ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1565
GMcache::ip_ex_bb_phi_tautau_ATLAS13
double ip_ex_bb_phi_tautau_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1539
GMcache::g_func
gslpp::complex g_func(const double x) const
Definition: GMcache.cpp:3140
GMcache::THoEX_pp_Hpm_taunu_CMS13
double THoEX_pp_Hpm_taunu_CMS13
Definition: GMcache.h:985
GMcache::pp_A_gaga_TH13
double pp_A_gaga_TH13
Definition: GMcache.h:1041
GMcache::THoEX_pp_H5_hh_bbbb_CMS8
double THoEX_pp_H5_hh_bbbb_CMS8
Definition: GMcache.h:974
GMcache::log_cs_VBFH5pp_8
gslpp::matrix< double > log_cs_VBFH5pp_8
Definition: GMcache.h:123
GMcache::ip_ex_pp_phi_hh_gagabb_CMS13
double ip_ex_pp_phi_hh_gagabb_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2085
GMcache::ip_cs_VBFH5pp_8_cache
double ip_cs_VBFH5pp_8_cache[2][CacheSize]
Definition: GMcache.h:1478
GMcache::THoEX_pp_H5_ZZ_qqnunu_CMS13
double THoEX_pp_H5_ZZ_qqnunu_CMS13
Definition: GMcache.h:963
GMcache::ip_ex_pp_phi_ZZ_llqqnunull_CMS13_cache
double ip_ex_pp_phi_ZZ_llqqnunull_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1514
GMcache::gH5ppH5mH5m
double gH5ppH5mH5m
Definition: GMcache.h:1019
GMcache::ATLAS8_gg_A_hZ_tautauZ
gslpp::matrix< double > ATLAS8_gg_A_hZ_tautauZ
Definition: GMcache.h:130
GMcache::ip_ex_bb_A_hZ_bbZ_1_CMS13
double ip_ex_bb_A_hZ_bbZ_1_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2267
GeorgiMachacek::getsina
double getsina() const
A method to get .
Definition: GeorgiMachacek.h:234
GMcache::SigmaHppHmm58
double SigmaHppHmm58
Definition: GMcache.h:1392
GMcache::Br_HtoZga
double Br_HtoZga
Definition: GMcache.h:936
GMcache::CMS13_pp_phi_bb
gslpp::matrix< double > CMS13_pp_phi_bb
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_hh_bbbb_1_CMS13
double ip_ex_pp_phi_hh_bbbb_1_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance decaying to two bosons...
Definition: GMcache.cpp:2029
GMcache::ip_ex_gg_phi_Zga_qqga_ATLAS13_cache
double ip_ex_gg_phi_Zga_qqga_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1506
GMcache::ATLAS13_bb_phi_tautau
gslpp::matrix< double > ATLAS13_bb_phi_tautau
Definition: GMcache.h:130
GeorgiMachacek::getinputmHh2
double getinputmHh2() const
A method to get the squared mass of the singlet Higgs input.
Definition: GeorgiMachacek.h:326
GMcache::gg_H_hh_TH8
double gg_H_hh_TH8
Definition: GMcache.h:1052
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:718
GMcache::SigmaVH_H13
double SigmaVH_H13
Definition: GMcache.h:1390
StandardModel::computeBrHtocc
double computeBrHtocc() const
The Br in the Standard Model.
Definition: StandardModel.h:2276
GMcache::ip_cs_ggtoHp_13
double ip_cs_ggtoHp_13(double mHp, double logtb)
Interpolating function for the H+ production cross section from two gluons at 13 TeV.
Definition: GMcache.cpp:1010
GMcache::ip_ex_pp_phi_hh_gagabb_CMS8_cache
double ip_ex_pp_phi_hh_gagabb_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1529
GMcache::THoEX_bb_A_tautau_ATLAS13
double THoEX_bb_A_tautau_ATLAS13
Definition: GMcache.h:951
GMcache::THoEX_pp_H_hh_bbbb_2_CMS13
double THoEX_pp_H_hh_bbbb_2_CMS13
Definition: GMcache.h:972
GMcache::THoEX_bb_H_tautau_CMS8
double THoEX_bb_H_tautau_CMS8
Definition: GMcache.h:948
GMcache::ip_cs_VBFH5mm_13_cache
double ip_cs_VBFH5mm_13_cache[2][CacheSize]
Definition: GMcache.h:1475
GMcache::ip_cs_VHH5mm_13
double ip_cs_VHH5mm_13(double mass)
Definition: GMcache.cpp:1314
GMcache::THoEX_pp_H_bb_CMS13
double THoEX_pp_H_bb_CMS13
Definition: GMcache.h:946
GMcache::pp_H5_VV_TH13
double pp_H5_VV_TH13
Definition: GMcache.h:1051
GMcache::THoEX_pp_H5_Zga_llga_ATLAS8
double THoEX_pp_H5_Zga_llga_ATLAS8
Definition: GMcache.h:957
GMcache::M2sq
double M2sq
Definition: GMcache.h:1431
GMcache::ip_ex_VV_H5ppmm_WW_jjll_CMS8
double ip_ex_VV_H5ppmm_WW_jjll_CMS8(double mH5)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2603
GMcache::CacheCheck
int CacheCheck(const gslpp::complex cache[][CacheSize], const int NumPar, const double params[]) const
Check whether for the latest set of parameters a value is in the cache.
Definition: GMcache.cpp:168
GMcache::SigmaSumH13
double SigmaSumH13
Definition: GMcache.h:1379
GMcache::CMS8_pp_A_phiZ_bbll
gslpp::matrix< double > CMS8_pp_A_phiZ_bbll
Definition: GMcache.h:130
GMcache::ip_ex_VV_phi_ZZ_ATLAS8_cache
double ip_ex_VV_phi_ZZ_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1509
GMcache::log_cs_VHH5pp_13
gslpp::matrix< double > log_cs_VHH5pp_13
Definition: GMcache.h:125
GMcache::I_h_L_cache
gslpp::complex I_h_L_cache[5][CacheSize]
Definition: GMcache.h:1179
GMcache::GammaHtot_SM
gslpp::matrix< double > GammaHtot_SM
Total SM decay width (obtained with HDECAY 6.10), depending on the Higgs mass.
Definition: GMcache.h:69
GMcache::ip_cs_ZtoZH_8
double ip_cs_ZtoZH_8(double mass)
Interpolating function for the Z associated H production cross section at 8 TeV.
Definition: GMcache.cpp:763
GMcache::THoEX_VV_H5ppmm_WW_jjll_CMS13
double THoEX_VV_H5ppmm_WW_jjll_CMS13
Definition: GMcache.h:990
GMcache::gH5H5pH5m
double gH5H5pH5m
Definition: GMcache.h:1016
GMcache::rHH_VV
double rHH_VV
Definition: GMcache.h:934
GMcache::ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e
double ip_ex_WZ_H5pm_WZ_lnull_ATLAS13_e(double mH5)
Interpolating function for the expected ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2477
GMcache::unitarityeigenvalues
gslpp::vector< gslpp::complex > unitarityeigenvalues
Definition: GMcache.h:930
GMcache::THoEX_VV_H_ZZ_llllnunu_ATLAS13
double THoEX_VV_H_ZZ_llllnunu_ATLAS13
Definition: GMcache.h:958
GMcache::A_H_Hp_cache
gslpp::complex A_H_Hp_cache[5][CacheSize]
Definition: GMcache.h:1195
GMcache::pp_H5_gaga_TH13
double pp_H5_gaga_TH13
Definition: GMcache.h:1042
GMcache::GM_Br_h_tautau
double GM_Br_h_tautau
Definition: GMcache.h:935
GMcache::tt_H_tt_TH13
double tt_H_tt_TH13
Definition: GMcache.h:1021
GMcache::THoEX_pp_A_gaga_ATLAS13
double THoEX_pp_A_gaga_ATLAS13
Definition: GMcache.h:953
GMcache::THoEX_WZ_H5pm_WZ_lnull_ATLAS13
double THoEX_WZ_H5pm_WZ_lnull_ATLAS13
Definition: GMcache.h:988
GMcache::gHH3H3
double gHH3H3
Definition: GMcache.h:1003
GMcache::CMS8_pp_phi_hh_bbbb
gslpp::matrix< double > CMS8_pp_phi_hh_bbbb
Definition: GMcache.h:130
GMcache::rh_ff
double rh_ff
Definition: GMcache.h:933
GMcache::ip_ex_pp_A_phiZ_bbll_CMS8_cache
double ip_ex_pp_A_phiZ_bbll_CMS8_cache[3][CacheSize]
Definition: GMcache.h:1553
GMcache::CMS13_pp_phi_WW_lnuqq
gslpp::matrix< double > CMS13_pp_phi_WW_lnuqq
Definition: GMcache.h:130
GMcache::mHl
double mHl
Definition: GMcache.h:1420
GMcache::CMS8_pp_phi_AZ_bbll
gslpp::matrix< double > CMS8_pp_phi_AZ_bbll
Definition: GMcache.h:130
GMcache::A_A_U
gslpp::complex A_A_U(const double mA2, const double cW2, const double Mc, const double Mt, const double MZ) const
Definition: GMcache.cpp:2953
GMcache::ip_ex_pp_phi_bb_CMS13_cache
double ip_ex_pp_phi_bb_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1490
GMcache::Br_Htohh
double Br_Htohh
Definition: GMcache.h:936
GMcache::CMS13_pp_phi_hh_bbtautau_1
gslpp::matrix< double > CMS13_pp_phi_hh_bbtautau_1
Definition: GMcache.h:130
GMcache::THoEX_VV_H5_ZZ_llllnunu_ATLAS13
double THoEX_VV_H5_ZZ_llllnunu_ATLAS13
Definition: GMcache.h:961
StandardModel::computeBrHtoWW
double computeBrHtoWW() const
The Br in the Standard Model.
Definition: StandardModel.h:2196
GMcache::ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8_cache
double ip_ex_pp_H5ppmmH5mmpp_mumumumu_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1571
GMcache::I_A_D_cache
gslpp::complex I_A_D_cache[4][CacheSize]
Definition: GMcache.h:1178
GMcache::ip_cs_VHH5_8_cache
double ip_cs_VHH5_8_cache[2][CacheSize]
Definition: GMcache.h:1480
GMcache::ip_cs_pptottH_8_cache
double ip_cs_pptottH_8_cache[2][CacheSize]
Definition: GMcache.h:1456
GMcache::THoEX_pp_H5_Zga_llga_CMS8
double THoEX_pp_H5_Zga_llga_CMS8
Definition: GMcache.h:957
GMcache::Br_Hptotb
double Br_Hptotb
Definition: GMcache.h:939
GMcache::Br_HtoZZ
double Br_HtoZZ
Definition: GMcache.h:936
GMcache::ip_cs_VBFH5p_13
double ip_cs_VBFH5p_13(double mass)
Definition: GMcache.cpp:1200
GMcache::THoEX_pp_H5ppmmH5mmpp_eeee_ATLAS8
double THoEX_pp_H5ppmmH5mmpp_eeee_ATLAS8
Definition: GMcache.h:989
GMcache::bb_H_bb_TH13
double bb_H_bb_TH13
Definition: GMcache.h:1023
GMcache::gg_A_tautau_TH8
double gg_A_tautau_TH8
Definition: GMcache.h:1039
QCD::STRANGE
Definition: QCD.h:327
GMcache::ip_ex_bb_A_phiZ_bbll_ATLAS13
double ip_ex_bb_A_phiZ_bbll_ATLAS13(double mA, double mH)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2351
GMcache::rh_VV
double rh_VV
Definition: GMcache.h:933
GMcache::ip_ex_pp_phi_hh_bbtautau_2_CMS13
double ip_ex_pp_phi_hh_bbtautau_2_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2127
GMcache::gH5ppH3mH3m
double gH5ppH3mH3m
Definition: GMcache.h:1018
GMcache::VV_H_ZZ_TH8
double VV_H_ZZ_TH8
Definition: GMcache.h:1046
GMcache::CMS8_pp_phi_hh_bbtautau
gslpp::matrix< double > CMS8_pp_phi_hh_bbtautau
Definition: GMcache.h:130
lambda5
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:474
GMcache::ip_cs_VBFtoH_8_cache
double ip_cs_VBFtoH_8_cache[2][CacheSize]
Definition: GMcache.h:1450
GMcache::THoEX_gg_A_hZ_bbZ_1_CMS13
double THoEX_gg_A_hZ_bbZ_1_CMS13
Definition: GMcache.h:980
GMcache::rh_Zga
double rh_Zga
Definition: GMcache.h:933
GMcache::THoEX_WZ_H5pm_WZ_lnull_1_CMS13
double THoEX_WZ_H5pm_WZ_lnull_1_CMS13
Definition: GMcache.h:988
GMcache::bb_H_tautau_TH13
double bb_H_tautau_TH13
Definition: GMcache.h:1038
GMcache::ip_ex_bb_phi_tautau_CMS13_cache
double ip_ex_bb_phi_tautau_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1499
GMcache::THoEX_gg_H_Zga_llga_ATLAS13
double THoEX_gg_H_Zga_llga_ATLAS13
Definition: GMcache.h:955
GMcache::THoEX_gg_A_tautau_ATLAS8
double THoEX_gg_A_tautau_ATLAS8
Definition: GMcache.h:950
GMcache::ip_cs_VHH5mm_8_cache
double ip_cs_VHH5mm_8_cache[2][CacheSize]
Definition: GMcache.h:1482
GMcache::ip_cs_WtoWH_13
double ip_cs_WtoWH_13(double mass)
Interpolating function for the W associated H production cross section at 13 TeV.
Definition: GMcache.cpp:744
GMcache::Ale
double Ale
Definition: GMcache.h:1415
GMcache::THoEX_bb_A_hZ_bbZ_ATLAS13
double THoEX_bb_A_hZ_bbZ_ATLAS13
Definition: GMcache.h:979
GMcache::THoEX_bb_H_tautau_ATLAS8
double THoEX_bb_H_tautau_ATLAS8
Definition: GMcache.h:948
GMcache::ip_cs_VBFH5m_8_cache
double ip_cs_VBFH5m_8_cache[2][CacheSize]
Definition: GMcache.h:1472
GMcache::ip_ex_WZ_H5pm_WZ_qqll_ATLAS8
double ip_ex_WZ_H5pm_WZ_qqll_ATLAS8(double mH5)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2491
GMcache::mH5sq
double mH5sq
Definition: GMcache.h:1427
GMcache::SigmaVBF_H58
double SigmaVBF_H58
Definition: GMcache.h:1378
GMcache::Br_AtoZga
double Br_AtoZga
Definition: GMcache.h:938
GMcache::THoEX_gg_A_hZ_bbll_CMS8
double THoEX_gg_A_hZ_bbll_CMS8
Definition: GMcache.h:978
GMcache::WZ_H5pm_WZ_TH13
double WZ_H5pm_WZ_TH13
Definition: GMcache.h:1068
GMcache::Br_Atott
double Br_Atott
Definition: GMcache.h:938
GMcache::ip_cs_VBFH5m_13
double ip_cs_VBFH5m_13(double mass)
Definition: GMcache.cpp:1124
GMcache::Int1
gslpp::complex Int1(const double tau, const double lambda) const
Definition: GMcache.cpp:3152
GMcache::ip_cs_ppH5ppH5mm_8
double ip_cs_ppH5ppH5mm_8(double mass)
Definition: GMcache.cpp:1029
GMcache::ATLAS8_gg_phi_gaga
gslpp::matrix< double > ATLAS8_gg_phi_gaga
Definition: GMcache.h:130
GMcache::br_bb
gslpp::matrix< double > br_bb
Definition: GMcache.h:64
GMcache::ip_ex_pp_Hpm_taunu_ATLAS8_cache
double ip_ex_pp_Hpm_taunu_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1557
GMcache::ip_ex_gg_A_hZ_bbll_CMS8
double ip_ex_gg_A_hZ_bbll_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2183
GMcache::ip_cs_ppH5ppH5mm_13_cache
double ip_cs_ppH5ppH5mm_13_cache[2][CacheSize]
Definition: GMcache.h:1469
GMcache::ip_ex_pp_Hp_taunu_CMS8_cache
double ip_ex_pp_Hp_taunu_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1558
GMcache::ip_ex_bb_A_hZ_bbZ_2_CMS13_cache
double ip_ex_bb_A_hZ_bbZ_2_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1552
GMcache::Br_Htott
double Br_Htott
Definition: GMcache.h:936
StandardModel::computeBrHtogg
double computeBrHtogg() const
The Br in the Standard Model.
Definition: StandardModel.h:2185
GMcache::THoEX_gg_A_HZ_bbll_ATLAS13
double THoEX_gg_A_HZ_bbll_ATLAS13
Definition: GMcache.h:982
GMcache::CMS13_pp_phi_hh_bbtautau_2
gslpp::matrix< double > CMS13_pp_phi_hh_bbtautau_2
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_ZZ_qqnunu_CMS13
double ip_ex_pp_phi_ZZ_qqnunu_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1791
GMcache::Br_AtohZ
double Br_AtohZ
Definition: GMcache.h:938
GMcache::pp_H_gaga_TH13
double pp_H_gaga_TH13
Definition: GMcache.h:1040
GMcache::ip_Br_HPtott
double ip_Br_HPtott(double mass)
Interpolating function for the SM branching ratio to two top quarks.
Definition: GMcache.cpp:522
GMcache::SigmaSumA13
double SigmaSumA13
Definition: GMcache.h:1380
GMcache::ip_Br_HPtobb_cache
double ip_Br_HPtobb_cache[2][CacheSize]
Definition: GMcache.h:1441
GMcache::myGM
const GeorgiMachacek * myGM
Definition: GMcache.h:1112
GMcache::pp_Hpm_taunu_TH8
double pp_Hpm_taunu_TH8
Definition: GMcache.h:1066
GMcache::log_cs_VBFH5mm_13
gslpp::matrix< double > log_cs_VBFH5mm_13
Definition: GMcache.h:122
GMcache::ip_Br_HPtott_cache
double ip_Br_HPtott_cache[2][CacheSize]
Definition: GMcache.h:1440
GMcache::THoEX_bb_A_HZ_bbll_ATLAS13
double THoEX_bb_A_HZ_bbll_ATLAS13
Definition: GMcache.h:982
GMcache::ip_ex_mu_pp_phi_VV_CMS8_cache
double ip_ex_mu_pp_phi_VV_CMS8_cache[2][CacheSize]
Definition: GMcache.h:1525
GMcache::ip_ex_WZ_H5pm_WZ_lnull_1_CMS13
double ip_ex_WZ_H5pm_WZ_lnull_1_CMS13(double mH5)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2505
GMcache::THoEX_bb_A_bb_CMS8
double THoEX_bb_A_bb_CMS8
Definition: GMcache.h:947
GMcache::pp_A_bb_TH13
double pp_A_bb_TH13
Definition: GMcache.h:1024
GMcache::GammaH3tot
double GammaH3tot
Total decay width of the CP-odd Higgs .
Definition: GMcache.h:1082
GMcache::ip_ex_pp_phi_hh_bbtautau_CMS8
double ip_ex_pp_phi_hh_bbtautau_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2001
GMcache::log_cs_bbA_8
gslpp::matrix< double > log_cs_bbA_8
Definition: GMcache.h:104
GMcache::gg_H_hh_TH13
double gg_H_hh_TH13
Definition: GMcache.h:1061
GMcache::log_cs_VHH5_8
gslpp::matrix< double > log_cs_VHH5_8
Definition: GMcache.h:124
GMcache::Br_AtoH5Z
double Br_AtoH5Z
Definition: GMcache.h:938
GMcache::ip_ex_pp_Hpm_tb_ATLAS8_cache
double ip_ex_pp_Hpm_tb_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1561
GMcache::Br_HptoHW
double Br_HptoHW
Definition: GMcache.h:939
StandardModel::getMHl
virtual double getMHl() const
A get method to retrieve the Higgs mass .
Definition: StandardModel.h:765
GMcache::CMS13_VV_H5ppmm_WW_jjll
gslpp::matrix< double > CMS13_VV_H5ppmm_WW_jjll
Definition: GMcache.h:130
GMcache::SigmaggF_H13
double SigmaggF_H13
Definition: GMcache.h:1382
GMcache::log_cs_ppH5ppH5mm_13
gslpp::matrix< double > log_cs_ppH5ppH5mm_13
Definition: GMcache.h:121
GMcache::gg_H_hh_bbtautau_TH8
double gg_H_hh_bbtautau_TH8
Definition: GMcache.h:1052
GMcache::THoEX_pp_H5_ZZ_llqqnunull_CMS13
double THoEX_pp_H5_ZZ_llqqnunull_CMS13
Definition: GMcache.h:962
GMcache::THoEX_pp_H5_hh_gagabb_CMS13
double THoEX_pp_H5_hh_gagabb_CMS13
Definition: GMcache.h:976
GMcache::pp_A_Zga_llga_TH8
double pp_A_Zga_llga_TH8
Definition: GMcache.h:1044
GMcache::ip_cs_ZtoZH_8_cache
double ip_cs_ZtoZH_8_cache[2][CacheSize]
Definition: GMcache.h:1454
GMcache::ip_cs_pptottA_8_cache
double ip_cs_pptottA_8_cache[2][CacheSize]
Definition: GMcache.h:1462
GMcache::ATLAS13_gg_phi_tautau
gslpp::matrix< double > ATLAS13_gg_phi_tautau
Definition: GMcache.h:130
GMcache::gg_H_bb_TH8
double gg_H_bb_TH8
Definition: GMcache.h:1023
GMcache::ip_ex_bb_A_hZ_bbZ_2_CMS13
double ip_ex_bb_A_hZ_bbZ_2_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2295
GMcache::computeOtherHiggsProperties
void computeOtherHiggsProperties()
Definition: GMcache.cpp:3303
GMcache::ip_ex_pp_phi_ZZ_llqqnunull_CMS13
double ip_ex_pp_phi_ZZ_llqqnunull_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1763
GMcache::log_cs_VBFH5m_13
gslpp::matrix< double > log_cs_VBFH5m_13
Definition: GMcache.h:122
GMcache::ATLAS8_pp_Hpm_tb
gslpp::matrix< double > ATLAS8_pp_Hpm_tb
Definition: GMcache.h:130
GMcache::Br_HtoAA
double Br_HtoAA
Definition: GMcache.h:936
GMcache::A_HH_D_cache
gslpp::complex A_HH_D_cache[6][CacheSize]
Definition: GMcache.h:1189
GMcache::CMS8_gg_phi_tautau
gslpp::matrix< double > CMS8_gg_phi_tautau
Definition: GMcache.h:130
GMcache::pp_Hpm_taunu_TH13
double pp_Hpm_taunu_TH13
Definition: GMcache.h:1066
GMcache::ip_GammaHPtotSM_cache
double ip_GammaHPtotSM_cache[2][CacheSize]
Definition: GMcache.h:1447
GMcache::THoEX_VV_H5_ZZ_ATLAS8
double THoEX_VV_H5_ZZ_ATLAS8
Definition: GMcache.h:961
GMcache::A_H_W_cache
gslpp::complex A_H_W_cache[5][CacheSize]
Definition: GMcache.h:1194
GMcache::pp_H5ppmmH5mmpp_TH13
double pp_H5ppmmH5mmpp_TH13
Definition: GMcache.h:1069
GMcache::OffShellFunction
double OffShellFunction(const double k) const
Definition: GMcache.cpp:3284
GMcache::ip_ex_gg_A_hZ_bbZ_1_CMS13_cache
double ip_ex_gg_A_hZ_bbZ_1_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1549
GMcache::CMS13_gg_phi_tautau
gslpp::matrix< double > CMS13_gg_phi_tautau
Definition: GMcache.h:130
GMcache::vPhi
double vPhi
Definition: GMcache.h:996
GMcache::ATLAS13_pp_H5ppmmH5mmpp_WWWW
gslpp::matrix< double > ATLAS13_pp_H5ppmmH5mmpp_WWWW
Definition: GMcache.h:130
GMcache::sumModBRs
double sumModBRs
Definition: GMcache.h:935
GMcache::THoEX_VV_H_ZZ_qqllnunu_ATLAS13
double THoEX_VV_H_ZZ_qqllnunu_ATLAS13
Definition: GMcache.h:959
GMcache::ip_ex_gg_phi_WW_ATLAS8
double ip_ex_gg_phi_WW_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1805
GMcache::I_A_D
gslpp::complex I_A_D(const double mA2, const double Ms, const double Mb) const
Definition: GMcache.cpp:2813
GMcache::Br_H5ptoWZ
double Br_H5ptoWZ
Definition: GMcache.h:942
GMcache::ip_ex_pp_phi_hh_gagabb_CMS8
double ip_ex_pp_phi_hh_gagabb_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1973
GMcache::ip_ex_VV_phi_WW_ATLAS8_cache
double ip_ex_VV_phi_WW_ATLAS8_cache[2][CacheSize]
Definition: GMcache.h:1518
GMcache::ip_ex_gg_phi_gaga_CMS13
double ip_ex_gg_phi_gaga_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1595
GMcache::bb_H_bb_TH8
double bb_H_bb_TH8
Definition: GMcache.h:1023
GMcache::I_HH_L
gslpp::complex I_HH_L(const double mHh2, const double Mmu, const double Mtau) const
Definition: GMcache.cpp:2848
GMcache::A_h_L_cache
gslpp::complex A_h_L_cache[7][CacheSize]
Definition: GMcache.h:1191
GMcache::CMS13_pp_phi_ZZ_llqqnunull
gslpp::matrix< double > CMS13_pp_phi_ZZ_llqqnunull
Definition: GMcache.h:130
GMcache::THoEX_bb_H_tt_ATLAS13
double THoEX_bb_H_tt_ATLAS13
Definition: GMcache.h:944
GMcache::CacheCheckReal
int CacheCheckReal(const double cache[][CacheSize], const int NumPar, const double params[]) const
Check whether for the latest set of parameters a value is in the cache.
Definition: GMcache.cpp:180
GMcache::ip_ex_gg_phi_hh_bbbb_CMS13_cache
double ip_ex_gg_phi_hh_bbbb_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1535
GMcache::THoEX_pp_H5ppmmH5mmpp_emuemu_ATLAS8
double THoEX_pp_H5ppmmH5mmpp_emuemu_ATLAS8
Definition: GMcache.h:989
GMcache::gH3H3H5
double gH3H3H5
Definition: GMcache.h:1012
GMcache::ip_cs_ggtoH_13
double ip_cs_ggtoH_13(double mass)
Interpolating function for the H production cross section via gluon-gluon fusion at 13 TeV.
Definition: GMcache.cpp:668
GMcache::Br_HptoH5ppW
double Br_HptoH5ppW
Definition: GMcache.h:939
GMcache::readTable
void readTable(gslpp::matrix< double > &arrayTab, std::string filename, int rowN, int colN)
This function reads values from a table and returns them as an array.
Definition: GMcache.cpp:2634
GMcache::A_HH_L_cache
gslpp::complex A_HH_L_cache[6][CacheSize]
Definition: GMcache.h:1192
GMcache::ip_Br_HPtotautau
double ip_Br_HPtotautau(double mass)
Interpolating function for the SM branching ratio to two tau leptons.
Definition: GMcache.cpp:554
GMcache::pp_H_hh_TH8
double pp_H_hh_TH8
Definition: GMcache.h:1052
GMcache::ip_ex_pp_Hp_taunu_CMS8
double ip_ex_pp_Hp_taunu_CMS8(double mHp)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2379
GMcache::ip_Br_HPtocc
double ip_Br_HPtocc(double mass)
Interpolating function for the SM branching ratio to two charm quarks.
Definition: GMcache.cpp:570
GMcache::ip_ex_tt_phi_tt_ATLAS13
double ip_ex_tt_phi_tt_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1371
GMcache::ip_ex_gg_A_hZ_bbZ_1_CMS13
double ip_ex_gg_A_hZ_bbZ_1_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2253
GMcache::THoEX_pp_H_hh_bbbb_1_CMS13
double THoEX_pp_H_hh_bbbb_1_CMS13
Definition: GMcache.h:972
GMcache::tt_A_tt_TH13
double tt_A_tt_TH13
Definition: GMcache.h:1022
GMcache::CMS13_ggVV_phi_WW_lnulnu
gslpp::matrix< double > CMS13_ggVV_phi_WW_lnulnu
Definition: GMcache.h:130
GMcache::THoEX_VV_H5_WW_enumunu_ATLAS13
double THoEX_VV_H5_WW_enumunu_ATLAS13
Definition: GMcache.h:966
GMcache::ip_ex_pp_phi_hh_bblnulnu_CMS13
double ip_ex_pp_phi_hh_bblnulnu_CMS13(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2141
GMcache::THoEX_ggVV_H_WW_lnulnu_CMS13
double THoEX_ggVV_H_WW_lnulnu_CMS13
Definition: GMcache.h:965
GMcache::mHl2
double mHl2
Definition: GMcache.h:1421
QCD::DOWN
Definition: QCD.h:325
GMcache::ATLAS8_WZ_H5pm_WZ_qqll
gslpp::matrix< double > ATLAS8_WZ_H5pm_WZ_qqll
Definition: GMcache.h:130
GMcache::ip_ex_pp_phi_hh_gagabb_ATLAS13
double ip_ex_pp_phi_hh_gagabb_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2071
GMcache::ip_ex_pp_phi_hh_bblnulnu_CMS13_cache
double ip_ex_pp_phi_hh_bblnulnu_CMS13_cache[2][CacheSize]
Definition: GMcache.h:1541
GMcache::ip_ex_pp_phi_hh_bbbb_ATLAS13_cache
double ip_ex_pp_phi_hh_bbbb_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1532
GMcache::ip_cs_pptottA_8
double ip_cs_pptottA_8(double mass)
Interpolating function for the top associated A production cross section at 8 TeV.
Definition: GMcache.cpp:915
GMcache::log_cs_bbH_13
gslpp::matrix< double > log_cs_bbH_13
SM Higgs production cross section table at 13 TeV obtained with SusHi 1.5, depending on the Higgs mas...
Definition: GMcache.h:99
GMcache::ip_cs_VHH5mm_13_cache
double ip_cs_VHH5mm_13_cache[2][CacheSize]
Definition: GMcache.h:1483
GMcache::ip_ex_gg_phi_hh_gagaWW_ATLAS13
double ip_ex_gg_phi_hh_gagaWW_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2155
GMcache::THoEX_gg_H_bb_CMS8
double THoEX_gg_H_bb_CMS8
Definition: GMcache.h:946
GMcache::THoEX_pp_H5_hh_bbtautau_CMS8
double THoEX_pp_H5_hh_bbtautau_CMS8
Definition: GMcache.h:975
GMcache::ip_ex_gg_A_hZ_bbZ_ATLAS8
double ip_ex_gg_A_hZ_bbZ_ATLAS8(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2169
GMcache::pp_H5_ZZ_TH13
double pp_H5_ZZ_TH13
Definition: GMcache.h:1047
StandardModel::getAle
double getAle() const
A get method to retrieve the fine-structure constant .
Definition: StandardModel.h:745
GMcache::SigmaHp8
double SigmaHp8
Definition: GMcache.h:1392
GMcache::I_h_D_cache
gslpp::complex I_h_D_cache[5][CacheSize]
Definition: GMcache.h:1176
GMcache::gg_H_tautau_TH8
double gg_H_tautau_TH8
Cross section times branching ratio for the process at the LHC with 8 TeV.
Definition: GMcache.h:1030
GMcache::gg_A_hZ_tautaull_TH8
double gg_A_hZ_tautaull_TH8
Definition: GMcache.h:1063
GMcache::Br_H5toHpHm
double Br_H5toHpHm
Definition: GMcache.h:940
GMcache::THoEX_WZ_H5pm_WZ_lnull_2_CMS13
double THoEX_WZ_H5pm_WZ_lnull_2_CMS13
Definition: GMcache.h:988
GMcache::THoEX_pp_H_VV_qqqq_ATLAS13
double THoEX_pp_H_VV_qqqq_ATLAS13
Definition: GMcache.h:968
GMcache::Gamma_h
double Gamma_h
Definition: GMcache.h:935
GMcache::vev
double vev
Definition: GMcache.h:1419
GMcache::ip_ex_mu_pp_phi_VV_CMS8
double ip_ex_mu_pp_phi_VV_CMS8(double mass)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:1917
GMcache::gg_A_bb_TH8
double gg_A_bb_TH8
Definition: GMcache.h:1024
GMcache::A_H_W
gslpp::complex A_H_W(const double mH, const double cW2, const double MW, const double MZ) const
Definition: GMcache.cpp:3095
GMcache::THoEX_bb_A_hZ_bbZ_2_CMS13
double THoEX_bb_A_hZ_bbZ_2_CMS13
Definition: GMcache.h:980
GMcache::Br_H5toAZ
double Br_H5toAZ
Definition: GMcache.h:940
GMcache::VV_H5_ZZ_TH13
double VV_H5_ZZ_TH13
Definition: GMcache.h:1047
GMcache::SigmaHp513
double SigmaHp513
Definition: GMcache.h:1392
GMcache::THoEX_pp_Hpm_tb_ATLAS13
double THoEX_pp_Hpm_tb_ATLAS13
Definition: GMcache.h:987
GMcache::Br_Atotautau
double Br_Atotautau
Definition: GMcache.h:938
GMcache::Br_H5ptoAW
double Br_H5ptoAW
Definition: GMcache.h:942
GMcache::log_cs_ggH_13
gslpp::matrix< double > log_cs_ggH_13
SM Higgs production cross section tables at 13 TeV from the LHC Higgs Cross Section Working Group,...
Definition: GMcache.h:79
GMcache::ip_ex_pp_phi_gaga_ATLAS13
double ip_ex_pp_phi_gaga_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:1581
GMcache::ip_ex_pp_phi_hh_gagabb_ATLAS13_cache
double ip_ex_pp_phi_hh_gagabb_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1536
GMcache::ATLAS8_pp_H5ppmmH5mmpp_emuemu
gslpp::matrix< double > ATLAS8_pp_H5ppmmH5mmpp_emuemu
Definition: GMcache.h:130
GMcache::br_ZZ
gslpp::matrix< double > br_ZZ
Definition: GMcache.h:64
GMcache::log_cs_ZH_13
gslpp::matrix< double > log_cs_ZH_13
Definition: GMcache.h:79
GMcache::THoEX_pp_H_hh_bbtautau_CMS8
double THoEX_pp_H_hh_bbtautau_CMS8
Definition: GMcache.h:971
GMcache::ip_cs_VBFH5mm_8
double ip_cs_VBFH5mm_8(double mass)
Definition: GMcache.cpp:1143
GMcache::ip_cs_VBFtoH_13
double ip_cs_VBFtoH_13(double mass)
Interpolating function for the H production cross section via vector boson fusion at 13 TeV.
Definition: GMcache.cpp:706
GMcache::SigmabbF_A8
double SigmabbF_A8
Definition: GMcache.h:1376
QCD::MU
Definition: QCD.h:314
GMcache::sinb
double sinb
Definition: GMcache.h:995
GMcache::gg_A_hZ_bbZ_TH13
double gg_A_hZ_bbZ_TH13
Definition: GMcache.h:1063
GMcache::ip_ex_bb_A_hZ_bbZ_ATLAS13
double ip_ex_bb_A_hZ_bbZ_ATLAS13(double mass)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2239
GMcache::ip_ex_pp_Hpm_tb_ATLAS13
double ip_ex_pp_Hpm_tb_ATLAS13(double mHp)
Interpolating function for the observed ATLAS upper limit on a scalar resonance.
Definition: GMcache.cpp:2449
GMcache::Br_Htogaga
double Br_Htogaga
Definition: GMcache.h:936
GMcache::gg_H_ZZ_TH13
double gg_H_ZZ_TH13
Definition: GMcache.h:1046
GMcache::ip_ex_pp_Hpm_taunu_CMS13
double ip_ex_pp_Hpm_taunu_CMS13(double mHp)
Interpolating function for the observed CMS upper limit on a scalar resonance.
Definition: GMcache.cpp:2407
GMcache::ghH5pH5m
double ghH5pH5m
Definition: GMcache.h:1008
GMcache::pp_Hp_taunu_TH8
double pp_Hp_taunu_TH8
Definition: GMcache.h:1066
GMcache::ip_cs_VBFH5m_13_cache
double ip_cs_VBFH5m_13_cache[2][CacheSize]
Definition: GMcache.h:1473
GMcache::rh_gaga
double rh_gaga
Definition: GMcache.h:933
GMcache::THoEX_pp_H5ppmmH5mmpp_llll_ATLAS13
double THoEX_pp_H5ppmmH5mmpp_llll_ATLAS13
Definition: GMcache.h:990
GMcache::pp_H5_WW_TH13
double pp_H5_WW_TH13
Definition: GMcache.h:1049
GMcache::SigmaSumH8
double SigmaSumH8
SM branching ratio of .
Definition: GMcache.h:1368
GMcache::ip_ex_VV_phi_WW_enumunu_ATLAS13_cache
double ip_ex_VV_phi_WW_enumunu_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1520
GMcache::ip_cs_VBFH5p_8
double ip_cs_VBFH5p_8(double mass)
Definition: GMcache.cpp:1181
GMcache::ip_ex_gg_phi_hh_gagaWW_ATLAS13_cache
double ip_ex_gg_phi_hh_gagaWW_ATLAS13_cache[2][CacheSize]
Definition: GMcache.h:1542
GMcache::THoEX_pp_H5_hh_bbbb_CMS13
double THoEX_pp_H5_hh_bbbb_CMS13
Definition: GMcache.h:976
GMcache::THoEX_gg_A_hZ_bbZ_ATLAS8
double THoEX_gg_A_hZ_bbZ_ATLAS8
Definition: GMcache.h:978
GMcache::THoEX_bb_H_tautau_ATLAS13
double THoEX_bb_H_tautau_ATLAS13
Definition: GMcache.h:949
StandardModel::getLeptons
Particle getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
Definition: StandardModel.h:709
GMcache::CacheShift
void CacheShift(gslpp::complex cache[][CacheSize], const int NumPar, const double params[], const gslpp::complex newResult) const
Adds a new result and its parameters into the cache.
Definition: GMcache.cpp:192
GMcache::cW2
double cW2
Definition: GMcache.h:1417
GMcache::THoEX_VV_H5_WW_lnuqq_ATLAS13
double THoEX_VV_H5_WW_lnuqq_ATLAS13
Definition: GMcache.h:967
GMcache::ATLAS13_gg_A_Zh_Zbb
gslpp::matrix< double > ATLAS13_gg_A_Zh_Zbb
Definition: GMcache.h:130
GMcache::THoEX_bb_A_tautau_CMS8
double THoEX_bb_A_tautau_CMS8
Definition: GMcache.h:950
GMcache::THoEX_gg_H_WW_enumunu_ATLAS13
double THoEX_gg_H_WW_enumunu_ATLAS13
Definition: GMcache.h:964