a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
GeneralTHDM.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2016 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
8#include "GeneralTHDM.h"
9#include "GeneralTHDMcache.h"
10#include "GeneralTHDMSTU.h"
11#include <algorithm>
12
13
14std::string GeneralTHDM::GeneralTHDMvars[NGeneralTHDMvars] = {"mHp2", "mH2sq", "mH3sq", "alpha1", "alpha2", "alpha3",
15"lambda2", "lambda3", "Relambda7",
16"Nu_11r", "Nu_11i", "Nu_12r", "Nu_12i", "Nu_13r", "Nu_13i",
17"Nu_21r", "Nu_21i", "Nu_22r", "Nu_22i", "Nu_23r", "Nu_23i",
18"Nu_31r", "Nu_31i", "Nu_32r", "Nu_32i", "Nu_33r", "Nu_33i",
19"Nd_11r", "Nd_11i", "Nd_12r", "Nd_12i", "Nd_13r", "Nd_13i",
20"Nd_21r", "Nd_21i", "Nd_22r", "Nd_22i", "Nd_23r", "Nd_23i",
21"Nd_31r", "Nd_31i", "Nd_32r", "Nd_32i", "Nd_33r", "Nd_33i",
22"Nl_11r", "Nl_11i", "Nl_12r", "Nl_12i", "Nl_13r", "Nl_13i",
23"Nl_21r", "Nl_21i", "Nl_22r", "Nl_22i", "Nl_23r", "Nl_23i",
24"Nl_31r", "Nl_31i", "Nl_32r", "Nl_32i", "Nl_33r", "Nl_33i",
25"Q_GTHDM","RpepsGTHDM","NLOuniscaleGTHDM"};
26
27GeneralTHDM::GeneralTHDM() : NPbase(), GTHDMM(*this) {
28
29 SMM.setObj((StandardModelMatching&) GTHDMM.getObj());
30 //ModelParamMap.insert(std::make_pair("logtb", std::cref(logtb)));
31
32 ModelParamMap.insert(std::make_pair("mH1", std::cref(mH1)));
33 ModelParamMap.insert(std::make_pair("mHp", std::cref(mHp1)));
34 ModelParamMap.insert(std::make_pair("mH2", std::cref(mH21)));
35 ModelParamMap.insert(std::make_pair("mH3", std::cref(mH31)));
36
37 ModelParamMap.insert(std::make_pair("mH1sq", std::cref(mH1sq)));
38 ModelParamMap.insert(std::make_pair("mHp2", std::cref(mHp2)));
39 ModelParamMap.insert(std::make_pair("mH2sq", std::cref(mH2sq)));
40 ModelParamMap.insert(std::make_pair("mH3sq", std::cref(mH3sq)));
41 ModelParamMap.insert(std::make_pair("alpha1", std::cref(alpha1)));
42 ModelParamMap.insert(std::make_pair("alpha2", std::cref(alpha2)));
43 ModelParamMap.insert(std::make_pair("alpha3", std::cref(alpha3)));
44 ModelParamMap.insert(std::make_pair("lambda1", std::cref(lambda1)));
45 ModelParamMap.insert(std::make_pair("lambda2", std::cref(lambda2)));
46 ModelParamMap.insert(std::make_pair("lambda3", std::cref(lambda3)));
47 ModelParamMap.insert(std::make_pair("lambda4", std::cref(lambda4)));
48 ModelParamMap.insert(std::make_pair("Relambda5", std::cref(Relambda5)));
49 ModelParamMap.insert(std::make_pair("Imlambda5", std::cref(Imlambda5)));
50 ModelParamMap.insert(std::make_pair("Relambda6", std::cref(Relambda6)));
51 ModelParamMap.insert(std::make_pair("Relambda7", std::cref(Relambda7)));
52
53 ModelParamMap.insert(std::make_pair("yu1R_GTHDM", std::cref(yu1R_GTHDM)));
54 ModelParamMap.insert(std::make_pair("yd1R_GTHDM", std::cref(yd1R_GTHDM)));
55 ModelParamMap.insert(std::make_pair("yl1R_GTHDM", std::cref(yl1R_GTHDM)));
56
57
58
59 ModelParamMap.insert(std::make_pair("Nu_11r", std::cref(Nu_11r)));
60 ModelParamMap.insert(std::make_pair("Nu_11i", std::cref(Nu_11i)));
61 ModelParamMap.insert(std::make_pair("Nu_12r", std::cref(Nu_12r)));
62 ModelParamMap.insert(std::make_pair("Nu_12i", std::cref(Nu_12i)));
63 ModelParamMap.insert(std::make_pair("Nu_13r", std::cref(Nu_13r)));
64 ModelParamMap.insert(std::make_pair("Nu_13i", std::cref(Nu_13i)));
65 ModelParamMap.insert(std::make_pair("Nu_21r", std::cref(Nu_21r)));
66 ModelParamMap.insert(std::make_pair("Nu_21i", std::cref(Nu_21i)));
67 ModelParamMap.insert(std::make_pair("Nu_22r", std::cref(Nu_22r)));
68 ModelParamMap.insert(std::make_pair("Nu_22i", std::cref(Nu_22i)));
69 ModelParamMap.insert(std::make_pair("Nu_23r", std::cref(Nu_23r)));
70 ModelParamMap.insert(std::make_pair("Nu_23i", std::cref(Nu_23i)));
71 ModelParamMap.insert(std::make_pair("Nu_31r", std::cref(Nu_31r)));
72 ModelParamMap.insert(std::make_pair("Nu_31i", std::cref(Nu_31i)));
73 ModelParamMap.insert(std::make_pair("Nu_32r", std::cref(Nu_32r)));
74 ModelParamMap.insert(std::make_pair("Nu_32i", std::cref(Nu_32i)));
75 ModelParamMap.insert(std::make_pair("Nu_33r", std::cref(Nu_33r)));
76 ModelParamMap.insert(std::make_pair("Nu_33i", std::cref(Nu_33i)));
77 ModelParamMap.insert(std::make_pair("Nd_11r", std::cref(Nd_11r)));
78 ModelParamMap.insert(std::make_pair("Nd_11i", std::cref(Nd_11i)));
79 ModelParamMap.insert(std::make_pair("Nd_12r", std::cref(Nd_12r)));
80 ModelParamMap.insert(std::make_pair("Nd_12i", std::cref(Nd_12i)));
81 ModelParamMap.insert(std::make_pair("Nd_13r", std::cref(Nd_13r)));
82 ModelParamMap.insert(std::make_pair("Nd_13i", std::cref(Nd_13i)));
83 ModelParamMap.insert(std::make_pair("Nd_21r", std::cref(Nd_21r)));
84 ModelParamMap.insert(std::make_pair("Nd_21i", std::cref(Nd_21i)));
85 ModelParamMap.insert(std::make_pair("Nd_22r", std::cref(Nd_22r)));
86 ModelParamMap.insert(std::make_pair("Nd_22i", std::cref(Nd_22i)));
87 ModelParamMap.insert(std::make_pair("Nd_23r", std::cref(Nd_23r)));
88 ModelParamMap.insert(std::make_pair("Nd_23i", std::cref(Nd_23i)));
89 ModelParamMap.insert(std::make_pair("Nd_31r", std::cref(Nd_31r)));
90 ModelParamMap.insert(std::make_pair("Nd_31i", std::cref(Nd_31i)));
91 ModelParamMap.insert(std::make_pair("Nd_32r", std::cref(Nd_32r)));
92 ModelParamMap.insert(std::make_pair("Nd_32i", std::cref(Nd_32i)));
93 ModelParamMap.insert(std::make_pair("Nd_33r", std::cref(Nd_33r)));
94 ModelParamMap.insert(std::make_pair("Nd_33i", std::cref(Nd_33i)));
95 ModelParamMap.insert(std::make_pair("Nl_11r", std::cref(Nl_11r)));
96 ModelParamMap.insert(std::make_pair("Nl_11i", std::cref(Nl_11i)));
97 ModelParamMap.insert(std::make_pair("Nl_12r", std::cref(Nl_12r)));
98 ModelParamMap.insert(std::make_pair("Nl_12i", std::cref(Nl_12i)));
99 ModelParamMap.insert(std::make_pair("Nl_13r", std::cref(Nl_13r)));
100 ModelParamMap.insert(std::make_pair("Nl_13i", std::cref(Nl_13i)));
101 ModelParamMap.insert(std::make_pair("Nl_21r", std::cref(Nl_21r)));
102 ModelParamMap.insert(std::make_pair("Nl_21i", std::cref(Nl_21i)));
103 ModelParamMap.insert(std::make_pair("Nl_22r", std::cref(Nl_22r)));
104 ModelParamMap.insert(std::make_pair("Nl_22i", std::cref(Nl_22i)));
105 ModelParamMap.insert(std::make_pair("Nl_23r", std::cref(Nl_23r)));
106 ModelParamMap.insert(std::make_pair("Nl_23i", std::cref(Nl_23i)));
107 ModelParamMap.insert(std::make_pair("Nl_31r", std::cref(Nl_31r)));
108 ModelParamMap.insert(std::make_pair("Nl_31i", std::cref(Nl_31i)));
109 ModelParamMap.insert(std::make_pair("Nl_32r", std::cref(Nl_32r)));
110 ModelParamMap.insert(std::make_pair("Nl_32i", std::cref(Nl_32i)));
111 ModelParamMap.insert(std::make_pair("Nl_33r", std::cref(Nl_33r)));
112 ModelParamMap.insert(std::make_pair("Nl_33i", std::cref(Nl_33i)));
113 ModelParamMap.insert(std::make_pair("Q_GTHDM", std::cref(Q_GTHDM)));
114 ModelParamMap.insert(std::make_pair("RpepsGTHDM", std::cref(RpepsGTHDM)));
115 ModelParamMap.insert(std::make_pair("NLOuniscaleGTHDM", std::cref(NLOuniscaleGTHDM)));
116 flag_use_sq_masses=true;
117 flag_sigma=true;
118 flag_ATHDM = false;
119 flag_CPconservation = false;
120 flag_SM_Higgs = false;
121
122
123}
124
125GeneralTHDM::~GeneralTHDM(){
126 if (IsModelInitialized()) {
127 if (myGTHDMcache != NULL) delete(myGTHDMcache);
128 }
129}
130
132// Initialization
133
134bool GeneralTHDM::InitializeModel()
135{
136 myGTHDMcache = new GeneralTHDMcache(*this);
137 setModelInitialized(NPbase::InitializeModel());
138 setModelGeneralTHDM();
139 return(IsModelInitialized());
140}
141
142
143bool GeneralTHDM::Update(const std::map<std::string, double>& DPars)
144{
145 if(!NPbase::Update(DPars)) return (false);
146
147
148
149
150
151 return (true);
152}
153
154
155
156bool GeneralTHDM::PostUpdate()
157{
158 trueSM.setComputemt(true);
159 if(!NPbase::PostUpdate()) return (false);
160
161
162 if(flag_CPconservation){
163 mu2=mHp2-lambda3/(2*v()*v());
164
165 mH1=mHl;
166
167 mH1sq=mH1*mH1;
168
169 lambda1 = (mH1sq+mH2sq*tanalpha1*tanalpha1)/(v()*v()*(1+tanalpha1*tanalpha1));
170
171 lambda4 = (mH1sq+mH3sq-2*mHp2+(mH2sq-mH1sq)/(1+tanalpha1*tanalpha1))/(v()*v());
172
173 Relambda5 = ((mH2sq+mH1sq*tanalpha1*tanalpha1)/(1+tanalpha1*tanalpha1)-mH3sq)/(v()*v());
174
175 Imlambda5 = 0.;
176
177 Relambda6 = ((mH1sq-mH2sq)*tanalpha1)/(v()*v()*(1+tanalpha1*tanalpha1));
178
179 Imlambda6 = 0.;
180
181 Imlambda7 = 0.;
182 }
183 else{
184 throw std::runtime_error("\033[1;31m The CP-Violating GeneralTHDM is still not implemented, please use the CP-conserving model \033[0m ");
185 }
186
187
188 gsl_set_error_handler(custom_gsl_error_handler);
189 myGTHDMcache->updateCache();
190
191 return (true);
192}
193
194void GeneralTHDM::setParameter(const std::string name, const double& value){
195
196// std::cout<<"\033[1;33m name = \033[0m "<< name << std::endl;
197// std::cout<<"\033[1;33m value = \033[0m "<< value << std::endl;
198
199
200 if(name.compare("mH21") == 0){
201 if(!flag_use_sq_masses){
202 mH21 = value;
203 mH2sq=mH21*mH21;
204 }
205 else{
206 throw std::runtime_error(" If flag_use_sq_masses is true you should not include"
207 " the linear mass as a parameter in the configuration file. Please comment that line");
208
209 //mH21=sqrt(mH2sq);
210 }
211 }
212 else if(name.compare("mH31") == 0){
213 if(!flag_use_sq_masses){
214 mH31 = value;
215 mH3sq = mH31*mH31;
216 }
217 else{
218 throw std::runtime_error(" If flag_use_sq_masses is true you should not include"
219 " the linear mass as a parameter in the configuration file. Please comment that line");
220 //mH31=sqrt(mH3sq);
221 }
222 }
223 else if(name.compare("mHp1") == 0){
224 if(!flag_use_sq_masses){
225 mHp1 = value;
226 mHp2 = mHp1*mHp1;
227 }
228 else{
229 throw std::runtime_error(" If flag_use_sq_masses is true you should not include"
230 " the linear mass as a parameter in the configuration file. Please comment that line");
231 //mHp1=sqrt(mHp2);
232 }
233 }
234
235 else if(name.compare("mH2sq") == 0){
236 if(flag_use_sq_masses){
237 mH2sq = value;
238 mH21=sqrt(mH2sq);
239 }
240 else{
241 throw std::runtime_error(" If flag_use_sq_masses is false you should not include"
242 " the quadratic mass as a parameter in the configuration file. Please comment that line");
243 //mH2sq=mH21*mH21;
244 }
245 }
246 else if(name.compare("mH3sq") == 0){
247 if(flag_use_sq_masses){
248 mH3sq = value;
249 mH31=sqrt(mH3sq);
250 }
251 else{
252 throw std::runtime_error(" If flag_use_sq_masses is false you should not include"
253 " the quadratic mass as a parameter in the configuration file. Please comment that line");
254 //mH3sq=mH31*mH31;
255 }
256 }
257 else if(name.compare("mHp2") == 0){
258 if(flag_use_sq_masses){
259 mHp2 = value;
260 mHp1=sqrt(mHp2);
261 }
262 else{
263 throw std::runtime_error(" If flag_use_sq_masses is false you should not include"
264 " the quadratic mass as a parameter in the configuration file. Please comment that line");
265 //mHp2=mHp1*mHp1;
266 }
267 }
268
269 else if(name.compare("alpha1") == 0) {
270 alpha1 = value;
271 cosalpha1 = cos(alpha1);
272 sinalpha1 = sin(alpha1);
273 if(cosalpha1 != 0){
274 tanalpha1 = sinalpha1/cosalpha1;
275 }
276 else{
277 std::cout<<"\033[1;33m Warning!!! The alpha1=pi/2 and it's tangent is infinity, reduce the range of alpha1 \033[0m "<<std::endl;
278 }
279
280 }
281 else if(name.compare("alpha2") == 0) {
282 alpha2 = value;
283 cosalpha2 = cos(alpha2);
284 sinalpha2 = sin(alpha2);
285 }
286 else if(name.compare("alpha3") == 0) {
287 alpha3 = value;
288 cosalpha3 = cos(alpha3);
289 sinalpha3 = sin(alpha3);
290 }
291 else if(name.compare("lambda2") == 0)
292 lambda2 = value;
293 else if(name.compare("lambda3") == 0)
294 lambda3 = value;
295 else if(name.compare("Relambda7") == 0)
296 Relambda7 = value;
297 else if(name.compare("Nu_11r") == 0 && flag_sigma)
298 Nu_11r = value;
299 else if(name.compare("yu1R_GTHDM") == 0 && !flag_sigma){
300 if(alpha1==0)
301 yu1R_GTHDM=1;
302 else
303 yu1R_GTHDM = value;
304 }
305 else if(name.compare("Nu_11i") == 0)
306 Nu_11i = value;
307 else if(name.compare("Nu_12r") == 0)
308 Nu_12r = value;
309 else if(name.compare("Nu_12i") == 0)
310 Nu_12i = value;
311 else if(name.compare("Nu_13r") == 0)
312 Nu_13r = value;
313 else if(name.compare("Nu_13i") == 0)
314 Nu_13i = value;
315 else if(name.compare("Nu_21r") == 0)
316 Nu_21r = value;
317 else if(name.compare("Nu_21i") == 0)
318 Nu_21i = value;
319 else if(name.compare("Nu_22r") == 0)
320 Nu_22r = value;
321 else if(name.compare("Nu_22i") == 0)
322 Nu_22i = value;
323 else if(name.compare("Nu_23r") == 0)
324 Nu_23r = value;
325 else if(name.compare("Nu_23i") == 0)
326 Nu_23i = value;
327 else if(name.compare("Nu_31r") == 0)
328 Nu_31r = value;
329 else if(name.compare("Nu_31i") == 0)
330 Nu_31i = value;
331 else if(name.compare("Nu_32r") == 0)
332 Nu_32r = value;
333 else if(name.compare("Nu_32i") == 0)
334 Nu_32i = value;
335 else if(name.compare("Nu_33r") == 0)
336 Nu_33r = value;
337 else if(name.compare("Nu_33i") == 0)
338 Nu_33i = value;
339 else if(name.compare("Nd_11r") == 0 && flag_sigma)
340 Nd_11r = value;
341 else if(name.compare("yd1R_GTHDM") == 0 && !flag_sigma)
342 if(alpha1==0)
343 yd1R_GTHDM=1;
344 else
345 yd1R_GTHDM = value;
346 else if(name.compare("Nd_11i") == 0)
347 Nd_11i = value;
348 else if(name.compare("Nd_12r") == 0)
349 Nd_12r = value;
350 else if(name.compare("Nd_12i") == 0)
351 Nd_12i = value;
352 else if(name.compare("Nd_13r") == 0)
353 Nd_13r = value;
354 else if(name.compare("Nd_13i") == 0)
355 Nd_13i = value;
356 else if(name.compare("Nd_21r") == 0)
357 Nd_21r = value;
358 else if(name.compare("Nd_21i") == 0)
359 Nd_21i = value;
360 else if(name.compare("Nd_22r") == 0)
361 Nd_22r = value;
362 else if(name.compare("Nd_22i") == 0)
363 Nd_22i = value;
364 else if(name.compare("Nd_23r") == 0)
365 Nd_23r = value;
366 else if(name.compare("Nd_23i") == 0)
367 Nd_23i = value;
368 else if(name.compare("Nd_31r") == 0)
369 Nd_31r = value;
370 else if(name.compare("Nd_31i") == 0)
371 Nd_31i = value;
372 else if(name.compare("Nd_32r") == 0)
373 Nd_32r = value;
374 else if(name.compare("Nd_32i") == 0)
375 Nd_32i = value;
376 else if(name.compare("Nd_33r") == 0)
377 Nd_33r = value;
378 else if(name.compare("Nd_33i") == 0)
379 Nd_33i = value;
380 else if(name.compare("Nl_11r") == 0 && flag_sigma)
381 Nl_11r = value;
382 else if(name.compare("yl1R_GTHDM") == 0 && !flag_sigma)
383 if(alpha1==0)
384 yl1R_GTHDM=1;
385 else
386 yl1R_GTHDM = value;
387 else if(name.compare("Nl_11i") == 0)
388 Nl_11i = value;
389 else if(name.compare("Nl_12r") == 0)
390 Nl_12r = value;
391 else if(name.compare("Nl_12i") == 0)
392 Nl_12i = value;
393 else if(name.compare("Nl_13r") == 0)
394 Nl_13r = value;
395 else if(name.compare("Nl_13i") == 0)
396 Nl_13i = value;
397 else if(name.compare("Nl_21r") == 0)
398 Nl_21r = value;
399 else if(name.compare("Nl_21i") == 0)
400 Nl_21i = value;
401 else if(name.compare("Nl_22r") == 0)
402 Nl_22r = value;
403 else if(name.compare("Nl_22i") == 0)
404 Nl_22i = value;
405 else if(name.compare("Nl_23r") == 0)
406 Nl_23r = value;
407 else if(name.compare("Nl_23i") == 0)
408 Nl_23i = value;
409 else if(name.compare("Nl_31r") == 0)
410 Nl_31r = value;
411 else if(name.compare("Nl_31i") == 0)
412 Nl_31i = value;
413 else if(name.compare("Nl_32r") == 0)
414 Nl_32r = value;
415 else if(name.compare("Nl_32i") == 0)
416 Nl_32i = value;
417 else if(name.compare("Nl_33r") == 0)
418 Nl_33r = value;
419 else if(name.compare("Nl_33i") == 0)
420 Nl_33i = value;
421 else if(name.compare("Q_GTHDM") == 0)
422 Q_GTHDM = value;
423 else if(name.compare("RpepsGTHDM") == 0)
424 RpepsGTHDM = value;
425 else if(name.compare("NLOuniscaleGTHDM") == 0)
426 NLOuniscaleGTHDM = value;
427 else
428 NPbase::setParameter(name,value);
429
430}
431
432bool GeneralTHDM::CheckParameters(const std::map<std::string, double>& DPars) {
433 for (int i = 0; i < NGeneralTHDMvars; i++) {
434 if (DPars.find(GeneralTHDMvars[i]) == DPars.end()) {
435 std::cout << "ERROR: missing mandatory GeneralTHDM parameter " << GeneralTHDMvars[i] << std::endl;
436 raiseMissingModelParameterCount();
437 addMissingModelParameter(GeneralTHDMvars[i]);
438 }
439 }
440 return(NPbase::CheckParameters(DPars));
441}
442
444// Flags
445
446bool GeneralTHDM::setFlagStr(const std::string name, const std::string value)
447{
448 bool res = false;
449 if(name.compare("RGEorder") == 0)
450 {
451 if (checkRGEorder(value))
452 {
453 flag_RGEorder = value;
454 res = true;
455 }
456 else
457 {
458 throw std::runtime_error("GeneralTHDM::setFlagStr(): Invalid flag "
459 + name + "=" + value);
460 }
461 }
462 else
463 {
464 res = NPbase::setFlagStr(name,value);
465 }
466
467 return(res);
468}
469
470bool GeneralTHDM::setFlag(const std::string name, const bool value)
471{
472 bool res = false;
473 if(name.compare("use_sq_masses") == 0) {
474 flag_use_sq_masses = value;
475 res = true;
476 if (!flag_use_sq_masses) {
477 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"mH2sq"))] = "mH21";
478 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"mH3sq"))] = "mH31";
479 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"mHp2"))] = "mHp1";
480
481 ModelParamMap.insert(std::make_pair("mH21", std::cref(mH21)));
482 ModelParamMap.insert(std::make_pair("mH31", std::cref(mH31)));
483 ModelParamMap.insert(std::make_pair("mHp1", std::cref(mHp1)));
484
485 }
486 }
487 else if(name.compare("use_sigma") == 0) {
488 std::cout<<"use_sigma = "<< value << std::endl;
489 flag_sigma = value;
490 res = true;
491 if (!flag_sigma && flag_CPconservation) {
492 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"Nu_11r"))] = "yu1R_GTHDM";
493 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"Nd_11r"))] = "yd1R_GTHDM";
494 GeneralTHDMvars[std::distance(GeneralTHDMvars,std::find(GeneralTHDMvars,GeneralTHDMvars+NGeneralTHDMvars,"Nl_11r"))] = "yl1R_GTHDM";
495
496 ModelParamMap.insert(std::make_pair("yu1R_GTHDM", std::cref(yu1R_GTHDM)));
497 ModelParamMap.insert(std::make_pair("yd1R_GTHDM", std::cref(yd1R_GTHDM)));
498 ModelParamMap.insert(std::make_pair("yl1R_GTHDM", std::cref(yl1R_GTHDM)));
499 }
500 if(!flag_sigma && !flag_CPconservation){
501 throw std::runtime_error("sigma flag different from true only in the CP-conserving");
502 }
503 }
504 else if(name.compare("ATHDMflag") == 0) {
505 std::cout<<"ATHDMflag = "<< value<<std::endl;
506 flag_ATHDM = value;
507 res = true;
508 }
509 else if(name.compare("CPconservation") == 0) {
510 std::cout<<"CPconservation = "<< value<<std::endl;
511 flag_CPconservation = value;
512 res = true;
513 }
514 else
515 res = NPbase::setFlag(name,value);
516
517 return(res);
518}
519
520
524
525//Maybe we should move this to a file called SignalStrenghts to make the code more cleaner
526
527
528const double GeneralTHDM::muggH(const double sqrt_s) const
529{
530 return getMyGTHDMCache()->rh_gg;
531}
532
533const double GeneralTHDM::muVBF(const double sqrt_s) const
534{
535 return getMyGTHDMCache()->rh_VV;
536}
537
538const double GeneralTHDM::mueeWBF(const double sqrt_s, const double Pol_em, const double Pol_ep) const
539{
540 return getMyGTHDMCache()->rh_VV;
541}
542
543const double GeneralTHDM::muWH(const double sqrt_s) const
544{
545 return getMyGTHDMCache()->rh_VV;
546}
547
548const double GeneralTHDM::muZH(const double sqrt_s) const
549{
550 return getMyGTHDMCache()->rh_VV;
551}
552
553const double GeneralTHDM::mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
554{
555 return getMyGTHDMCache()->rh_VV;
556}
557
558const double GeneralTHDM::muVH(const double sqrt_s) const
559{
560 return getMyGTHDMCache()->rh_VV;
561}
562
563const double GeneralTHDM::muVBFpVH(const double sqrt_s) const
564{
565 return getMyGTHDMCache()->rh_VV;
566}
567
568const double GeneralTHDM::muttH(const double sqrt_s) const
569{
570 //return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t);
571 return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO;
572}
573
574
575const double GeneralTHDM::mutH(const double sqrt_s) const
576{
577 //return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t);
578 return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO;
579}
580
581const double GeneralTHDM::mubbH(const double sqrt_s) const
582{
583 return getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO;
584}
585
586const double GeneralTHDM::muttHptH(const double sqrt_s) const
587{
588 return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO;
589}
590
591const double GeneralTHDM::muggHpVBFpbbH(const double sqrt_s) const
592{
593 double xsecggF = computeSigmaggH(sqrt_s);
594 double xsecVBF = computeSigmaVBF(sqrt_s);
595 double xsecbbH = computeSigmabbH(sqrt_s);
596 return (muggH(sqrt_s)*xsecggF + muVBF(sqrt_s)*xsecVBF + mubbH(sqrt_s)*xsecbbH)/(xsecggF+xsecVBF+xsecbbH);
597}
598
599const double GeneralTHDM::muggHpbbH(const double sqrt_s) const
600{
601 double xsecggF = computeSigmaggH(sqrt_s);
602 double xsecbbH = computeSigmabbH(sqrt_s);
603 return (muggH(sqrt_s)*xsecggF + mubbH(sqrt_s)*xsecbbH)/(xsecggF+xsecbbH);
604}
605
606const double GeneralTHDM::muggHpttHptHpbbH(const double sqrt_s) const
607{
608 double xsecggF = computeSigmaggH(sqrt_s);
609 double xsecttH = computeSigmattH(sqrt_s);
610 double xsectH = computeSigmatHq(sqrt_s);
611 double xsecbbH = computeSigmabbH(sqrt_s);
612 return (muggH(sqrt_s)*xsecggF + muttH(sqrt_s)*xsecttH + mutH(sqrt_s)*xsectH + mubbH(sqrt_s)*xsecbbH)/(xsecggF+xsecttH+xsectH+xsecbbH);
613}
614
615
616
617const double GeneralTHDM::computeGammaTotalRatio() const
618{
619 return getMyGTHDMCache()->sumModBRs;
620}
621
622const double GeneralTHDM::GammaTotal() const
623{
624 return getMyGTHDMCache()->Gamma_h;
625}
626
627const double GeneralTHDM::BrHggRatio() const
628{
629 return getMyGTHDMCache()->rh_gg / computeGammaTotalRatio();
630}
631
632const double GeneralTHDM::BrHWWRatio() const
633{
634 return getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
635}
636
637const double GeneralTHDM::BrHZZRatio() const
638{
639 return getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
640}
641
642const double GeneralTHDM::BrHZgaRatio() const
643{
644 return getMyGTHDMCache()->rh_Zga / computeGammaTotalRatio();
645}
646
647const double GeneralTHDM::BrHgagaRatio() const
648{
649 return getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
650}
651
652const double GeneralTHDM::BrHmumuRatio() const
653{
654 //return getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_mu*getMyGTHDMCache()->beta_h_mu) / computeGammaTotalRatio();
655 return (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO) / computeGammaTotalRatio();
656}
657
658const double GeneralTHDM::BrHtautauRatio() const
659{
660 //return getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_tau*getMyGTHDMCache()->beta_h_tau) / computeGammaTotalRatio();
661 return (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO) / computeGammaTotalRatio();
662}
663
664const double GeneralTHDM::BrHccRatio() const
665{
666 //return getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_c*getMyGTHDMCache()->beta_h_c) / computeGammaTotalRatio();
667 return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO) / computeGammaTotalRatio();
668}
669
670const double GeneralTHDM::BrHbbRatio() const
671{
672 //return getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b) / computeGammaTotalRatio();
673 return (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO) / computeGammaTotalRatio();
674}
675
678
679const double GeneralTHDM::muggHgaga(const double sqrt_s) const
680{
681 //return getMyGTHDMCache()->rh_gg * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
682 return muggH(sqrt_s)*BrHgagaRatio();
683}
684
685
686const double GeneralTHDM::muggHpbbH_Hgaga(const double sqrt_s) const
687{
688 //return getMyGTHDMCache()->rh_gg * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
689 return muggHpbbH(sqrt_s)*BrHgagaRatio();
690}
691
692
693const double GeneralTHDM::muVBFHgaga(const double sqrt_s) const
694{
695 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
696 return muVBF(sqrt_s)*BrHgagaRatio();
697}
698
699const double GeneralTHDM::muVHgaga(const double sqrt_s) const
700{
701 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
702 return muVH(sqrt_s)*BrHgagaRatio();
703}
704
705const double GeneralTHDM::muWHgaga(const double sqrt_s) const
706{
707 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
708 return muWH(sqrt_s)*BrHgagaRatio();
709}
710
711const double GeneralTHDM::muZHgaga(const double sqrt_s) const
712{
713 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
714 return muZH(sqrt_s)*BrHgagaRatio();
715}
716
717
718
719const double GeneralTHDM::muttHgaga(const double sqrt_s) const
720{
721 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)) * getMyGTHDMCache()->rh_gaga / computeGammaTotalRatio();
722 return muttH(sqrt_s)*BrHgagaRatio();
723}
724
725
726const double GeneralTHDM::mutHgaga(const double sqrt_s) const
727{
728 return mutH(sqrt_s)*BrHgagaRatio();
729}
730
731
732
733const double GeneralTHDM::muttHptH_Hgaga(const double sqrt_s) const
734{
735 return muttHptH(sqrt_s)*BrHgagaRatio();
736}
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758const double GeneralTHDM::muggHZZ(const double sqrt_s) const
759{
760 //return getMyGTHDMCache()->rh_gg * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
761 return muggH(sqrt_s)*BrHZZRatio();
762}
763const double GeneralTHDM::muggHpbbH_HZZ(const double sqrt_s) const
764{
765 return muggHpbbH(sqrt_s)*BrHZZRatio();
766}
767const double GeneralTHDM::muVBFHZZ(const double sqrt_s) const
768{
769 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
770 return muVBF(sqrt_s)*BrHZZRatio();
771}
772const double GeneralTHDM::muWHZZ(const double sqrt_s) const
773{
774 return muWH(sqrt_s)*BrHZZRatio();
775}
776const double GeneralTHDM::muZHZZ(const double sqrt_s) const
777{
778 return muZH(sqrt_s)*BrHZZRatio();
779}
780const double GeneralTHDM::muVHZZ(const double sqrt_s) const
781{
782 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
783 return muVH(sqrt_s)*BrHZZRatio();
784}
785const double GeneralTHDM::muttHZZ(const double sqrt_s) const
786{
787 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)) * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
788 return muttH(sqrt_s)*BrHZZRatio();
789}
790const double GeneralTHDM::muttHptH_HZZ(const double sqrt_s) const
791{
792 return muttHptH(sqrt_s)*BrHZZRatio();
793}
794
795
796
797
798
799
800const double GeneralTHDM::muggHWW(const double sqrt_s) const
801{
802 //return getMyGTHDMCache()->rh_gg * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
803 return muggH(sqrt_s)*BrHWWRatio();
804}
805const double GeneralTHDM::muggHpbbH_HWW(const double sqrt_s) const
806{
807 return muggHpbbH(sqrt_s)*BrHWWRatio();
808}
809
810
811
812const double GeneralTHDM::muVBFHWW(const double sqrt_s) const
813{
814 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
815 return muVBF(sqrt_s)*BrHWWRatio();
816}
817
818const double GeneralTHDM::muWHWW(const double sqrt_s) const
819{
820 return muWH(sqrt_s)*BrHWWRatio();
821}
822
823const double GeneralTHDM::muZHWW(const double sqrt_s) const
824{
825 return muZH(sqrt_s)*BrHWWRatio();
826}
827
828const double GeneralTHDM::muVHWW(const double sqrt_s) const
829{
830 //return getMyGTHDMCache()->rh_VV * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
831 return muVH(sqrt_s)*BrHWWRatio();
832}
833
834const double GeneralTHDM::muttHWW(const double sqrt_s) const
835{
836 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)) * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
837 return muttH(sqrt_s)*BrHWWRatio();
838}
839
840const double GeneralTHDM::muttHptH_HWW(const double sqrt_s) const
841{
842 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)) * getMyGTHDMCache()->rh_VV / computeGammaTotalRatio();
843 return muttHptH(sqrt_s)*BrHWWRatio();
844}
845
846
847
848
849const double GeneralTHDM::muggHbb(const double sqrt_s) const
850{
851 //return getMyGTHDMCache()->rh_gg * (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b)) / computeGammaTotalRatio();
852 return muggH(sqrt_s)*BrHbbRatio();
853}
854
855
856const double GeneralTHDM::muggHpVBFpbbH_Hbb(const double sqrt_s) const
857{
858 return muggHpVBFpbbH(sqrt_s)*BrHbbRatio();
859}
860
861
862const double GeneralTHDM::muVBFHbb(const double sqrt_s) const
863{
864 //return getMyGTHDMCache()->rh_VV * (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b)) / computeGammaTotalRatio();
865 return muVBF(sqrt_s)*BrHbbRatio();
866}
867
868const double GeneralTHDM::muWHbb(const double sqrt_s) const
869{
870 return muWH(sqrt_s)*BrHbbRatio();
871}
872
873const double GeneralTHDM::muZHbb(const double sqrt_s) const
874{
875 return muZH(sqrt_s)*BrHbbRatio();
876}
877
878const double GeneralTHDM::muVHbb(const double sqrt_s) const
879{
880 //return getMyGTHDMCache()->rh_VV * (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b)) / computeGammaTotalRatio();
881 return muVH(sqrt_s)*BrHbbRatio();
882}
883
884const double GeneralTHDM::muttHbb(const double sqrt_s) const
885{
886 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t))
887 // * (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b)) / computeGammaTotalRatio();
888 return muttH(sqrt_s)*BrHbbRatio();
889}
890
891const double GeneralTHDM::muttHptH_Hbb(const double sqrt_s) const
892{
893 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t))
894 // * (getMyGTHDMCache()->rh_QdQdE + getMyGTHDMCache()->rh_QdQdO/(getMyGTHDMCache()->beta_h_b*getMyGTHDMCache()->beta_h_b)) / computeGammaTotalRatio();
895 return muttHptH(sqrt_s)*BrHbbRatio();
896}
897
898
899
900const double GeneralTHDM::muVHcc(const double sqrt_s) const
901{
902 return muVH(sqrt_s)*BrHccRatio();
903}
904
905
906
907const double GeneralTHDM::muggHmumu(const double sqrt_s) const
908{
909 return muggH(sqrt_s)*BrHmumuRatio();
910}
911
912
913const double GeneralTHDM::muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
914{
915 return muggHpttHptHpbbH(sqrt_s)*BrHmumuRatio();
916}
917
918const double GeneralTHDM::muVBFHmumu(const double sqrt_s) const
919{
920 return muVBF(sqrt_s)*BrHmumuRatio();
921}
922
923const double GeneralTHDM::muVHmumu(const double sqrt_s) const
924{
925 return muVH(sqrt_s)*BrHmumuRatio();
926}
927
928const double GeneralTHDM::muttHptH_Hmumu(const double sqrt_s) const
929{
930 return muttHptH(sqrt_s)*BrHmumuRatio();
931}
932
933const double GeneralTHDM::muVBFpVH_Hmumu(const double sqrt_s) const
934{
935 return muVBFpVH(sqrt_s)*BrHmumuRatio();
936}
937
938const double GeneralTHDM::muggHtautau(const double sqrt_s) const
939{
940 //return getMyGTHDMCache()->rh_gg * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_tau*getMyGTHDMCache()->beta_h_tau)) / computeGammaTotalRatio();
941 return muggH(sqrt_s)*BrHtautauRatio();
942}
943
944const double GeneralTHDM::muggHpbbH_Htautau(const double sqrt_s) const
945{
946 return muggHpbbH(sqrt_s)*BrHtautauRatio();
947}
948
949const double GeneralTHDM::muVBFHtautau(const double sqrt_s) const
950{
951 //return getMyGTHDMCache()->rh_VV * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_tau*getMyGTHDMCache()->beta_h_tau)) / computeGammaTotalRatio();
952 return muVBF(sqrt_s)*BrHtautauRatio();
953}
954
955const double GeneralTHDM::muWHtautau(const double sqrt_s) const
956{
957 return muWH(sqrt_s)*BrHtautauRatio();
958}
959
960const double GeneralTHDM::muZHtautau(const double sqrt_s) const
961{
962 return muZH(sqrt_s)*BrHtautauRatio();
963}
964
965const double GeneralTHDM::muVHtautau(const double sqrt_s) const
966{
967 //return getMyGTHDMCache()->rh_VV * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_tau*getMyGTHDMCache()->beta_h_tau)) / computeGammaTotalRatio();
968 return muVH(sqrt_s)*BrHtautauRatio();
969}
970
971const double GeneralTHDM::muttHtautau(const double sqrt_s) const
972{
973 //return (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t))
974 // * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_tau*getMyGTHDMCache()->beta_h_tau)) / computeGammaTotalRatio();
975 return muttH(sqrt_s)*BrHtautauRatio();
976}
977
978const double GeneralTHDM::muttHptH_Htautau(const double sqrt_s) const
979{
980 return muttHptH(sqrt_s)*BrHtautauRatio();
981}
982
983const double GeneralTHDM::muppHmumu(const double sqrt_s) const
984{
985 if(sqrt_s==8)
986 {
987 //return (0.872 * getMyGTHDMCache()->rh_gg + 0.122 * getMyGTHDMCache()->rh_VV + 0.006 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)))
988 // * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_mu*getMyGTHDMCache()->beta_h_mu)) / computeGammaTotalRatio();
989 return (0.872 * getMyGTHDMCache()->rh_gg + 0.122 * getMyGTHDMCache()->rh_VV + 0.006 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO))
990 * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO) / computeGammaTotalRatio();
991
992 }
993 if(sqrt_s==13)
994 {
995 //return (0.871 * getMyGTHDMCache()->rh_gg + 0.119 * getMyGTHDMCache()->rh_VV + 0.010 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t)))
996 // * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO/(getMyGTHDMCache()->beta_h_mu*getMyGTHDMCache()->beta_h_mu)) / computeGammaTotalRatio();
997 return (0.871 * getMyGTHDMCache()->rh_gg + 0.119 * getMyGTHDMCache()->rh_VV + 0.010 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO))
998 * (getMyGTHDMCache()->rh_QlQlE + getMyGTHDMCache()->rh_QlQlO) / computeGammaTotalRatio();
999
1000 }
1001 else
1002 {
1003 throw std::runtime_error("The observable muppHmumu is only defined for 8 or 13 TeV.");
1004 }
1005}
1006
1007const double GeneralTHDM::muggHZga(const double sqrt_s) const
1008{
1009 return muggH(sqrt_s)*BrHZgaRatio();
1010}
1011
1012
1013const double GeneralTHDM::muVBFHZga(const double sqrt_s) const
1014{
1015 return muVBF(sqrt_s)*BrHZgaRatio();
1016}
1017
1018
1019const double GeneralTHDM::muppHZga(const double sqrt_s) const
1020{
1021 if(sqrt_s==8)
1022 {
1023 //return (0.872 * getMyGTHDMCache()->rh_gg + 0.122 * getMyGTHDMCache()->rh_VV + 0.006 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t))) * getMyGTHDMCache()->rh_Zga / computeGammaTotalRatio();
1024 return (0.872 * getMyGTHDMCache()->rh_gg + 0.122 * getMyGTHDMCache()->rh_VV + 0.006 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO)) * getMyGTHDMCache()->rh_Zga / computeGammaTotalRatio();
1025 }
1026 if(sqrt_s==13)
1027 {
1028 //return (0.871 * getMyGTHDMCache()->rh_gg + 0.119 * getMyGTHDMCache()->rh_VV + 0.010 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO/(getMyGTHDMCache()->beta_h_t*getMyGTHDMCache()->beta_h_t))) * getMyGTHDMCache()->rh_Zga / computeGammaTotalRatio();
1029 return (0.871 * getMyGTHDMCache()->rh_gg + 0.119 * getMyGTHDMCache()->rh_VV + 0.010 * (getMyGTHDMCache()->rh_QuQuE + getMyGTHDMCache()->rh_QuQuO)) * getMyGTHDMCache()->rh_Zga / computeGammaTotalRatio();
1030 }
1031 else
1032 {
1033 throw std::runtime_error("The observable muppHZga is only defined for 8 or 13 TeV.");
1034 }
1035}
1036
1037
1038
1039
1040const double GeneralTHDM::F(const double m02, const double m12) const {
1041 double F;
1042
1043 if(m02 == 0. && m12 != 0.) {
1044 F=0.5 * m12;
1045 } else if(m02 != 0. && m12 == 0.){
1046 F=0.5 * m02;
1047 } else if((m02 == 0. && m12 == 0.) || (fabs(m02-m12) < LEPS)){
1048 F=0.;
1049 } else if (m02 != 0 && m12 != 0){
1050 F=0.5 * (m02 + m12) - (m02 * m12) / (m02 - m12) * log(m02 / m12);
1051 } else
1052 throw std::runtime_error("Error in GeneralTHDM::F()");
1053 return (F);
1054}
1055
1056
1057
1058const double GeneralTHDM::GTHDMDeltaS() const
1059{
1060
1061
1062 //MAYBE WE CAN USE DIRECTLY THE PARAMETERS mH1sq, mH2sq, mH3sq, mHp2. IT'S A NONESENSE TO DEFINE THIS AGAIN...
1063 double mH1_2 = mH1sq;
1064 double mH2_2 = mH2sq;
1065 double mH3_2 = mH3sq;
1066 double mHp2= getmHp2();
1067
1068 double mHref_2 = getmH1sq();
1069 double R11 = myGTHDMcache->Rij_GTHDM(0,0);
1070 double R21 = myGTHDMcache->Rij_GTHDM(1,0);
1071 double R31 = myGTHDMcache->Rij_GTHDM(2,0);
1072
1073
1074 double R11_2 = R11*R11;
1075 double R21_2 = R21*R21;
1076 double R31_2 = R31*R31;
1077
1078
1079
1080 double MZ= getMz();
1081 double MZ2 = MZ*MZ;
1082
1083 gslpp::complex B00prime_MZ2_MZ2_mH_2_mH_3;
1084 gslpp::complex B00prime_MZ2_MZ2_mHp2_mHp2;
1085 gslpp::complex B00prime_MZ2_MZ2_mH_1_mH_3;
1086 gslpp::complex B00prime_MZ2_MZ2_mH_1_mH_2;
1087
1088
1089 gslpp::complex B00prime_MZ2_MZ2_MZ2_mH2_2;
1090 gslpp::complex B00prime_MZ2_MZ2_MZ2_mH1_2;
1091 gslpp::complex B0prime_MZ2_MZ2_MZ2_mH2_2;
1092 gslpp::complex B0prime_MZ2_MZ2_MZ2_mH1_2;
1093
1094 gslpp::complex B00prime_MZ2_MZ2_MZ2_mH3_2;
1095 gslpp::complex B0prime_MZ2_MZ2_MZ2_mH3_2;
1096
1097 gslpp::complex B00prime_MZ2_MZ2_MZ2_mHref_2;
1098 gslpp::complex B0prime_MZ2_MZ2_MZ2_mHref_2;
1099
1100
1101
1102 B00prime_MZ2_MZ2_mH_2_mH_3 = myGTHDMcache->B00_MZ2_MZ2_mHh2_mA2(MZ2,mH2_2,mH3_2) - myGTHDMcache->B00_MZ2_0_mHh2_mA2(MZ2,mH2_2,mH3_2);
1103 B00prime_MZ2_MZ2_mHp2_mHp2 = myGTHDMcache->B00_MZ2_MZ2_mHp2_mHp2(MZ2,mHp2) - myGTHDMcache->B00_MZ2_0_mHp2_mHp2(MZ2,mHp2);
1104 B00prime_MZ2_MZ2_mH_1_mH_3 = myGTHDMcache->B00_MZ2_MZ2_mHl2_mA2(MZ2,mH1_2,mH3_2) - myGTHDMcache->B00_MZ2_0_mHl2_mA2(MZ2,mH1_2,mH3_2);
1105 B00prime_MZ2_MZ2_mH_1_mH_2 = myGTHDMcache->B00_MZ2_MZ2_mHl2_mA2(MZ2,mH1_2,mH2_2) - myGTHDMcache->B00_MZ2_0_mHl2_mA2(MZ2,mH1_2,mH2_2);
1106
1107
1108 B00prime_MZ2_MZ2_MZ2_mH2_2 = myGTHDMcache->B00_MZ2_MZ2_MZ2_mHh2(MZ2,mH2_2) - myGTHDMcache->B00_MZ2_0_MZ2_mHh2(MZ2,mH2_2);
1109 B00prime_MZ2_MZ2_MZ2_mH1_2 = myGTHDMcache->B00_MZ2_MZ2_MZ2_mHl2(MZ2,mH1_2) - myGTHDMcache->B00_MZ2_0_MZ2_mHl2(MZ2,mH1_2);
1110 B0prime_MZ2_MZ2_MZ2_mH2_2 = myGTHDMcache->B0_MZ2_MZ2_MZ2_mHh2(MZ2,mH2_2) - myGTHDMcache->B0_MZ2_0_MZ2_mHh2(MZ2,mH2_2);
1111 B0prime_MZ2_MZ2_MZ2_mH1_2 = myGTHDMcache->B0_MZ2_MZ2_MZ2_mHl2(MZ2,mH1_2) - myGTHDMcache->B0_MZ2_0_MZ2_mHl2(MZ2,mH1_2);
1112 B00prime_MZ2_MZ2_MZ2_mH3_2 = myGTHDMcache->B00_MZ2_MZ2_MZ2_mHh2(MZ2,mH3_2) - myGTHDMcache->B00_MZ2_0_MZ2_mHh2(MZ2,mH3_2);
1113 B0prime_MZ2_MZ2_MZ2_mH3_2 = myGTHDMcache->B0_MZ2_MZ2_MZ2_mHh2(MZ2,mH3_2) - myGTHDMcache->B0_MZ2_0_MZ2_mHh2(MZ2,mH3_2);
1114
1115 B00prime_MZ2_MZ2_MZ2_mHref_2 = myGTHDMcache->B00_MZ2_MZ2_MZ2_mHh2(MZ2,mHref_2) - myGTHDMcache->B00_MZ2_0_MZ2_mHh2(MZ2,mHref_2);
1116 B0prime_MZ2_MZ2_MZ2_mHref_2 = myGTHDMcache->B0_MZ2_MZ2_MZ2_mHh2(MZ2,mHref_2) - myGTHDMcache->B0_MZ2_0_MZ2_mHh2(MZ2,mHref_2);
1117
1118
1119
1120
1121 return 1/MZ2/M_PI*( R11_2*(B00prime_MZ2_MZ2_MZ2_mH1_2.real() - MZ2*B0prime_MZ2_MZ2_MZ2_mH1_2.real())+
1122 R21_2*(B00prime_MZ2_MZ2_MZ2_mH2_2.real() - MZ2*B0prime_MZ2_MZ2_MZ2_mH2_2.real())+
1123 R31_2*(B00prime_MZ2_MZ2_MZ2_mH3_2.real() - MZ2*B0prime_MZ2_MZ2_MZ2_mH3_2.real())+
1124 R11_2*B00prime_MZ2_MZ2_mH_2_mH_3.real() + R21_2*B00prime_MZ2_MZ2_mH_1_mH_3.real()
1125 +R31_2*B00prime_MZ2_MZ2_mH_1_mH_2.real() - B00prime_MZ2_MZ2_mHp2_mHp2.real()
1126 - B00prime_MZ2_MZ2_MZ2_mHref_2.real() + MZ2*B0prime_MZ2_MZ2_MZ2_mHref_2.real());
1127
1128}
1129
1130
1131
1132const double GeneralTHDM::GTHDMDeltaT() const
1133{
1134
1135 gslpp::complex I = gslpp::complex::i();
1136 double mH1_2 = mH1sq;
1137 double mH2_2 = mH2sq;
1138 double mH3_2 = mH3sq;
1139 double mHp2 = getmHp2();
1140
1141 double mHref_2 = mH1sq;
1142
1143
1144
1145 double R11 = myGTHDMcache->Rij_GTHDM(0,0);
1146 double R12 = myGTHDMcache->Rij_GTHDM(0,1);
1147 double R13 = myGTHDMcache->Rij_GTHDM(0,2);
1148 double R21 = myGTHDMcache->Rij_GTHDM(1,0);
1149 double R22 = myGTHDMcache->Rij_GTHDM(1,1);
1150 double R23 = myGTHDMcache->Rij_GTHDM(1,2);
1151 double R31 = myGTHDMcache->Rij_GTHDM(2,0);
1152 double R32 = myGTHDMcache->Rij_GTHDM(2,1);
1153 double R33 = myGTHDMcache->Rij_GTHDM(2,2);
1154
1155
1156 double R11_2 = R11*R11;
1157 double R21_2 = R21*R21;
1158 double R31_2 = R31*R31;
1159
1160 double MZ=getMz();
1161 double MZ2 = MZ*MZ;
1162
1163 double MW=Mw_tree();
1164 double MW2 = MW*MW;
1165
1166 double s_W2 = 1.0-c02();
1167
1168 gslpp::complex B0_MZ2_0_MZ2_mH1_2;
1169 gslpp::complex B0_MZ2_0_MZ2_mH2_2;
1170 gslpp::complex B0_MZ2_0_MZ2_mH3_2;
1171 gslpp::complex B0_MZ2_0_MZ2_mHref_2;
1172
1173
1174 gslpp::complex B0_MZ2_0_MW2_mH1_2;
1175 gslpp::complex B0_MZ2_0_MW2_mH2_2;
1176 gslpp::complex B0_MZ2_0_MW2_mH3_2;
1177 gslpp::complex B0_MZ2_0_MW2_mHref_2;
1178
1179
1180 B0_MZ2_0_MZ2_mH1_2 = myGTHDMcache->B0_MZ2_0_MZ2_mHh2(MZ2,mH1_2);
1181 B0_MZ2_0_MZ2_mH2_2 = myGTHDMcache->B0_MZ2_0_MZ2_mHl2(MZ2,mH2_2);
1182 B0_MZ2_0_MZ2_mH3_2 = myGTHDMcache->B0_MZ2_0_MZ2_mHl2(MZ2,mH3_2);
1183 B0_MZ2_0_MZ2_mHref_2 = myGTHDMcache->B0_MZ2_0_MZ2_mHl2(MZ2,mHref_2);
1184
1185
1186 B0_MZ2_0_MW2_mH1_2 = myGTHDMcache->B0_MZ2_0_MW2_mHh2(MZ2,MW2,mH1_2);
1187 B0_MZ2_0_MW2_mH2_2 = myGTHDMcache->B0_MZ2_0_MW2_mHl2(MZ2,MW2,mH2_2);
1188 B0_MZ2_0_MW2_mH3_2 = myGTHDMcache->B0_MZ2_0_MW2_mHl2(MZ2,MW2,mH3_2);
1189 B0_MZ2_0_MW2_mHref_2 = myGTHDMcache->B0_MZ2_0_MW2_mHl2(MZ2,MW2,mHref_2);
1190
1191
1192 return 1. / 16. / M_PI / MW2 / s_W2*((R12 + I*R13).abs2()*F(mHp2, mH1_2)+(R22 + I*R23).abs2()*F(mHp2, mH2_2)+
1193 (R32 + I*R33).abs2()*F(mHp2, mH3_2)- R11_2*F(mH2_2, mH3_2) - R21_2*F(mH1_2, mH3_2) - R31_2*F(mH1_2, mH2_2)
1194 + R11_2*(F(MW2, mH1_2) - F(MZ2, mH1_2) - 4.0*MW2*B0_MZ2_0_MW2_mH1_2.real() + 4.0*MZ2*B0_MZ2_0_MZ2_mH1_2.real())
1195 + R21_2*(F(MW2, mH2_2) - F(MZ2, mH2_2) - 4.0*MW2*B0_MZ2_0_MW2_mH2_2.real() + 4.0*MZ2*B0_MZ2_0_MZ2_mH2_2.real())
1196 + R31_2*(F(MW2, mH3_2) - F(MZ2, mH3_2) - 4.0*MW2*B0_MZ2_0_MW2_mH3_2.real() + 4.0*MZ2*B0_MZ2_0_MZ2_mH3_2.real())
1197 -(F(MW2, mHref_2) - F(MZ2, mHref_2) - 4.0*MW2*B0_MZ2_0_MW2_mHref_2.real() + 4.0*MZ2*B0_MZ2_0_MZ2_mHref_2.real()));
1198
1199}
1200
1201
1202
1203const double GeneralTHDM::GTHDMDeltaU() const
1204{
1205
1206 gslpp::complex I = gslpp::complex::i();
1207 double mH1_2 = mH1sq;
1208 double mH2_2 = mH2sq;
1209 double mH3_2 = mH3sq;
1210 double mHp2 = getmHp2();
1211
1212 double mHref_2 = mH1sq;
1213
1214
1215
1216
1217 double R11 = myGTHDMcache->Rij_GTHDM(0,0);
1218 double R12 = myGTHDMcache->Rij_GTHDM(0,1);
1219 double R13 = myGTHDMcache->Rij_GTHDM(0,2);
1220 double R21 = myGTHDMcache->Rij_GTHDM(1,0);
1221 double R22 = myGTHDMcache->Rij_GTHDM(1,1);
1222 double R23 = myGTHDMcache->Rij_GTHDM(1,2);
1223 double R31 = myGTHDMcache->Rij_GTHDM(2,0);
1224 double R32 = myGTHDMcache->Rij_GTHDM(2,1);
1225 double R33 = myGTHDMcache->Rij_GTHDM(2,2);
1226
1227
1228 double R11_2 = R11*R11;
1229 double R21_2 = R21*R21;
1230 double R31_2 = R31*R31;
1231
1232 double MZ=getMz();
1233 double MZ2 = MZ*MZ;
1234
1235 double MW=Mw_tree();
1236 double MW2 = MW*MW;
1237
1238
1239 gslpp::complex B00prime_MZ2_MW2_mH1_2_mHp2;
1240 gslpp::complex B00prime_MZ2_MW2_mH2_2_mHp2;
1241 gslpp::complex B00prime_MZ2_MW2_mH3_2_mHp2;
1242 gslpp::complex B00prime_MZ2_MW2_mHref_2_mHp2;
1243
1244
1245
1246 gslpp::complex B00prime_MZ2_MW2_mHp2_mHp2;
1247
1248
1249 gslpp::complex B00prime_MZ2_MW2_MW2_mH1_2;
1250 gslpp::complex B00prime_MZ2_MW2_MW2_mH2_2;
1251 gslpp::complex B00prime_MZ2_MW2_MW2_mH3_2;
1252 gslpp::complex B00prime_MZ2_MW2_MW2_mHref_2;
1253
1254
1255 gslpp::complex B0prime_MZ2_MW2_MW2_mH1_2;
1256 gslpp::complex B0prime_MZ2_MW2_MW2_mH2_2;
1257 gslpp::complex B0prime_MZ2_MW2_MW2_mH3_2;
1258 gslpp::complex B0prime_MZ2_MW2_MW2_mHref_2;
1259
1260
1261
1262 B00prime_MZ2_MW2_mH1_2_mHp2 = myGTHDMcache->B00_MZ2_MW2_mHl2_mHp2(MZ2,MW2,mH1_2,mHp2) - myGTHDMcache->B00_MZ2_0_mHl2_mHp2(MZ2,mH1_2,mHp2);
1263 B00prime_MZ2_MW2_mH2_2_mHp2 = myGTHDMcache->B00_MZ2_MW2_mHh2_mHp2(MZ2,MW2,mH2_2,mHp2) - myGTHDMcache->B00_MZ2_0_mHh2_mHp2(MZ2,mH2_2,mHp2);
1264 B00prime_MZ2_MW2_mH3_2_mHp2 = myGTHDMcache->B00_MZ2_MW2_mHh2_mHp2(MZ2,MW2,mH3_2,mHp2) - myGTHDMcache->B00_MZ2_0_mHh2_mHp2(MZ2,mH3_2,mHp2);
1265 B00prime_MZ2_MW2_mHref_2_mHp2 = myGTHDMcache->B00_MZ2_MW2_mHl2_mHp2(MZ2,MW2,mHref_2,mHp2) - myGTHDMcache->B00_MZ2_0_mHl2_mHp2(MZ2,mHref_2,mHp2);
1266
1267 B00prime_MZ2_MW2_mHp2_mHp2 = myGTHDMcache->B00_MZ2_MW2_mHp2_mHp2(MZ2,MW2,mHp2) - myGTHDMcache->B00_MZ2_0_mHp2_mHp2(MZ2,mHp2);
1268
1269 B00prime_MZ2_MW2_MW2_mH1_2 = myGTHDMcache->B00_MZ2_MW2_MW2_mHl2(MZ2,MW2,mH1_2) - myGTHDMcache->B00_MZ2_0_MW2_mHl2(MZ2,MW2,mH1_2);
1270 B00prime_MZ2_MW2_MW2_mH2_2 = myGTHDMcache->B00_MZ2_MW2_MW2_mHh2(MZ2,MW2,mH2_2) - myGTHDMcache->B00_MZ2_0_MW2_mHh2(MZ2,MW2,mH2_2);
1271 B00prime_MZ2_MW2_MW2_mH3_2 = myGTHDMcache->B00_MZ2_MW2_MW2_mHh2(MZ2,MW2,mH3_2) - myGTHDMcache->B00_MZ2_0_MW2_mHh2(MZ2,MW2,mH3_2);
1272 B00prime_MZ2_MW2_MW2_mHref_2 = myGTHDMcache->B00_MZ2_MW2_MW2_mHl2(MZ2,MW2,mHref_2) - myGTHDMcache->B00_MZ2_0_MW2_mHl2(MZ2,MW2,mHref_2);
1273
1274 B0prime_MZ2_MW2_MW2_mH1_2 = myGTHDMcache->B0_MZ2_MW2_MW2_mHl2(MZ2,MW2,mH1_2) - myGTHDMcache->B0_MZ2_0_MW2_mHl2(MZ2,MW2,mH1_2);
1275 B0prime_MZ2_MW2_MW2_mH2_2 = myGTHDMcache->B0_MZ2_MW2_MW2_mHh2(MZ2,MW2,mH2_2) - myGTHDMcache->B0_MZ2_0_MW2_mHh2(MZ2,MW2,mH2_2);
1276 B0prime_MZ2_MW2_MW2_mH3_2 = myGTHDMcache->B0_MZ2_MW2_MW2_mHh2(MZ2,MW2,mH3_2) - myGTHDMcache->B0_MZ2_0_MW2_mHh2(MZ2,MW2,mH3_2);
1277 B0prime_MZ2_MW2_MW2_mHref_2 = myGTHDMcache->B0_MZ2_MW2_MW2_mHl2(MZ2,MW2,mHref_2) - myGTHDMcache->B0_MZ2_0_MW2_mHl2(MZ2,MW2,mHref_2);
1278
1279
1280 return - GTHDMDeltaS() + 1. / M_PI / MZ2 * (- R11_2*MW2*B0prime_MZ2_MW2_MW2_mH1_2.real() - R21_2*MW2*B0prime_MZ2_MW2_MW2_mH2_2.real() - R31_2*MW2*B0prime_MZ2_MW2_MW2_mH3_2.real()
1281 + MW2*B0prime_MZ2_MW2_MW2_mHref_2.real() - B00prime_MZ2_MW2_MW2_mHref_2.real()
1282 + R11_2* B00prime_MZ2_MW2_MW2_mH1_2.real() +R21_2* B00prime_MZ2_MW2_MW2_mH2_2.real() +R31_2* B00prime_MZ2_MW2_MW2_mH3_2.real()
1283 + (R12+I*R13).abs2()*B00prime_MZ2_MW2_mH1_2_mHp2.real() + (R22+I*R23).abs2()*B00prime_MZ2_MW2_mH2_2_mHp2.real()
1284 + (R32+I*R33).abs2()*B00prime_MZ2_MW2_mH3_2_mHp2.real() - 2. * B00prime_MZ2_MW2_mHp2_mHp2.real());
1285
1286
1287
1288}
1289
1290
1291
1292
1293
1294//Here we had before the at tree level but it would be better to include the full expression (including the oblique corrections).
1295const double GeneralTHDM::Mw() const{
1296
1297
1298 //std::cout<<"\033[1;33m GTHDMDeltaS() = \033[0m "<< GTHDMDeltaS() <<std::endl;
1299 //std::cout<<"\033[1;32m GTHDMDeltaT() = \033[0m "<< GTHDMDeltaT() <<std::endl;
1300 //std::cout<<"\033[1;31m GTHDMDeltaU() = \033[0m "<< GTHDMDeltaU() <<std::endl;
1301
1302 //std::cout<<"\033[1;31m trueSM.Mw() = \033[0m "<< trueSM.Mw() <<std::endl;
1303
1304 double myMw = trueSM.Mw();
1305
1306 double alpha = trueSM.alphaMz();
1307 double c2 = trueSM.cW2();
1308 double s2 = trueSM.sW2();
1309
1310 myMw *= 1.0 - alpha / 4.0 / (c2 - s2)
1311 *(GTHDMDeltaS() - 2.0 * c2 * GTHDMDeltaT() - (c2 - s2) * GTHDMDeltaU() / 2.0 / s2)
1312 - s2 / 2.0 / (c2 - s2) * DeltaGF();
1313
1314
1315 //std::cout<<"\033[1;31m myMw = \033[0m "<< myMw <<std::endl;
1316
1317 return (myMw);
1318// return (trueSM.Mw());
1319// return (Mw_tree());
1320}
DPars
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
GTHDMDeltaS
An observable class for the THDM contribution to the electroweak Peskin-Takeuchi pseudo-observable .
Definition: GeneralTHDMSTU.h:53
NPbase
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
NPbase::Update
virtual bool Update(const std::map< std::string, double > &DPars)
The update method for NPbase.
Definition: NPbase.cpp:36
NPbase::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of NPbase.
Definition: NPbase.h:97
StandardModel::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for StandardModel have been provided in model initi...
Definition: StandardModel/src/StandardModel.cpp:364
StandardModel::setFlagStr
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:508
StandardModel::PostUpdate
virtual bool PostUpdate()
The post-update method for StandardModel.
Definition: StandardModel/src/StandardModel.cpp:241
StandardModel::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.
Definition: StandardModel/src/StandardModel.cpp:278
StandardModel::InitializeModel
virtual bool InitializeModel()
A method to initialize the model.
Definition: StandardModel/src/StandardModel.cpp:174
StandardModelMatching
A class for the matching in the Standard Model.
Definition: StandardModelMatching.h:26
lambda1
parameter of the Higgs potential
Definition: THDMquantities.h:382
lambda2
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:405
lambda3
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:428
lambda4
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:451
mH1_2
tanbeta constructor.
Definition: GeneralTHDMquantities.h:46
mH2_2
The mass of the SM Higgs.
Definition: GeneralTHDMquantities.h:68
mH3_2
The mass of the SM Higgs.
Definition: GeneralTHDMquantities.h:91
muVBF
A class for computing the ratio .
Definition: HiggsThObservables.h:54
muVBFpVH
A class for computing the ratio .
Definition: HiggsThObservables.h:665
muVH
A class for computing the ratio .
Definition: HiggsThObservables.h:604
muWH
A class for computing the ratio .
Definition: HiggsThObservables.h:280
muZH
A class for computing the ratio .
Definition: HiggsThObservables.h:342
muggH
A class for computing the ratio .
Definition: HiggsThObservables.h:24
muttH
A class for computing the ratio .
Definition: HiggsThObservables.h:695