Hyperiso 1.0.3
Modular flavour-physics calculations, Wilson coefficients and statistical inference
Loading...
Searching...
No Matches
SUSYParametersHelper.cpp
Go to the documentation of this file.
1#include "SUSYParametersHelper.h"
2
3#include "Parameters.h"
4
5void SUSYParameterHelper::init(int gen, WGroupId) {
6
7 if (initialized) {
8 return;
9 }
10
11 LOG_INFO("Initializing scale independent SUSY parameters");
12 init_scale_independent_block(gen);
13 LOG_INFO("Initializing matching SUSY parameters");
14 init_matching_block();
15 LOG_INFO("Initializing epsilon block");
16 init_epsilon_block();
17 LOG_INFO("Done");
18
19 initialized = true;
20}
21
22void SUSYParameterHelper::init_epsilon_block() {
23 const auto bsm_blocks = Parameters::GetInstance(ParameterType::BSM)->get_block_accessor();
24
25 // Prefer the SLHA2 5x5 NMSSM matrix whenever it is available. Keeping the
26 // selected block name in the dependency list avoids mutating BlockAccessor
27 // aliases and also handles files that contain both NMIX and NMNMIX.
28 const std::string neutralino_mix_block =
29 bsm_blocks->contains("NMNMIX") ? "NMNMIX" : "NMIX";
30
31 std::unordered_map<ParameterType, std::vector<std::string>> src = {
32 {ParameterType::SM, {"MASS", "SMINPUTS"}},
33 {ParameterType::BSM, {"MASS", "GAUGE", "HMIX", "MSOFT", "AD", "AU", "SBOTMIX", "STOPMIX", "UMIX", "VMIX", neutralino_mix_block, "ALPHA"}},
34 {ParameterType::WILSON, {"WPARAM_SI_SM", "WPARAM_MATCH_SM"}}
35 };
36
37 // YU and YD are optional in SLHA spectrum output. Add them as sources
38 // only when the spectrum actually provides them; otherwise the update
39 // function below reconstructs y_t and y_b from running quark masses.
40 if (bsm_blocks->contains("YU")) src[ParameterType::BSM].push_back("YU");
41 if (bsm_blocks->contains("YD")) src[ParameterType::BSM].push_back("YD");
42
43 auto func = [neutralino_mix_block] (const BlockSrc& src, std::shared_ptr<DependentBlock> dep_block) {
44
45 src.get_val("ALPHA", LhaID());
46
47 double g2 = src.get_val("GAUGE", 2);
48 double alpha_em = src.get_val("SMINPUTS", 1);
49
50 // double m_ds = src.get_val("MASS", 1000001);
51 // double m_us = src.get_val("MASS", 1000002);
52 double m_ss = src.get_val("MASS", 1000003);
53 // double m_cs = src.get_val("MASS", 1000004);
54 double m_bs = src.get_val("MASS", 1000005);
55 double m_ts = src.get_val("MASS", 1000006);
56
57 // double m_d2s = src.get_val("MASS", 2000001);
58 // double m_u2s = src.get_val("MASS", 2000002);
59 // double m_s2s = src.get_val("MASS", 2000003);
60 // double m_c2s = src.get_val("MASS", 2000004);
61 double m_b2s = src.get_val("MASS", 2000005);
62 double m_t2s = src.get_val("MASS", 2000006);
63
64 double m_gluino = src.get_val("MASS", 1000021);
65 double m_c1 = src.get_val("MASS", 1000024);
66 double m_c2 = src.get_val("MASS", 1000037);
67 double mu_Q = src.get_val("HMIX", 1);
68
69 double mqL3 = src.get_val("MSOFT", 43);
70 double mbR = src.get_val("MSOFT", 49);
71
72 const auto mass_block = src.block("MASS");
73 const auto mass_if_present = [&](int pdg) {
74 return mass_block->contains(LhaID(pdg)) ? src.get_val("MASS", pdg) : scalar_t(.0);
75 };
76
77 std::vector<double> m_neutralino = {
78 src.get_val("MASS", 1000022),
79 src.get_val("MASS", 1000023),
80 src.get_val("MASS", 1000025),
81 src.get_val("MASS", 1000035)
82 };
83
84 // The NMSSM singlino-like fifth neutralino is PDG 1000045. The old
85 // code accidentally queried the gravitino (1000039) and then indexed
86 // past a four-element vector. Include state 5 only when both its mass
87 // and the required NMIX/NMNMIX entries are present.
88 const double m_neutralino5 = mass_if_present(1000045);
89 const bool has_neutralino5_mix =
90 src.block(neutralino_mix_block)->contains(LhaID(5, 3)) &&
91 src.block(neutralino_mix_block)->contains(LhaID(5, 4));
92 if (m_neutralino5 != 0.0 && has_neutralino5_mix) {
93 m_neutralino.push_back(m_neutralino5);
94 } else if (m_neutralino5 != 0.0) {
95 LOG_WARN("EPSILON_SUSY: MASS(1000045) is present but NMIX/NMNMIX row 5 is incomplete; ignoring neutralino 5.");
96 }
97 double ad_22 = src.get_val("AD", {3, 3});
98 double au_22 = src.get_val("AU", {3, 3});
99
100 const double tan_beta = src.get_val("HMIX", 2);
101 const double sin_beta = tan_beta / std::sqrt(1.0 + tan_beta * tan_beta);
102 const double cos_beta = 1.0 / std::sqrt(1.0 + tan_beta * tan_beta);
103 const double mW = src.get_val("MASS", 24);
104
105 const bool has_yu33 = src.has_block("YU") && src.block("YU")->contains(LhaID(3, 3));
106 const bool has_yd33 = src.has_block("YD") && src.block("YD")->contains(LhaID(3, 3));
107
108 // Prefer the running Yukawa blocks supplied by the spectrum generator.
109 // When they are absent, reconstruct the couplings at the matching scale
110 // from m_t(mu_W), m_b(mu_W), g2 and tan(beta):
111 // y_t = g2 m_t / (sqrt(2) m_W sin(beta)),
112 // y_b = g2 m_b / (sqrt(2) m_W cos(beta)).
113 const double yu_22 = has_yu33
114 ? src.get_val("YU", LhaID(3, 3))
115 : g2 * src.get_val("WPARAM_MATCH_SM", 6) / (std::sqrt(2.0) * mW * sin_beta);
116 const double yd_22 = has_yd33
117 ? src.get_val("YD", LhaID(3, 3))
118 : g2 * src.get_val("WPARAM_MATCH_SM", LhaID(5, 1)) / (std::sqrt(2.0) * mW * cos_beta);
119
120 if (!has_yu33 || !has_yd33) {
121 LOG_WARN("EPSILON_SUSY: YU(3,3)/YD(3,3) missing; using Yukawas reconstructed from running quark masses.");
122 }
123
124 double sbot_mix_00 = src.get_val("SBOTMIX", {0+1, 0+1});
125 double sbot_mix_01 = src.get_val("SBOTMIX", {0+1, 1+1});
126
127 double stop_mix_00 = src.get_val("STOPMIX", {0+1, 0+1});
128 double stop_mix_01 = src.get_val("STOPMIX", {0+1, 1+1});
129
130 double umix_01 = src.get_val("UMIX", {0+1, 1+1});
131 double umix_11 = src.get_val("UMIX", {1+1, 1+1});
132
133 double vmix_01 = src.get_val("VMIX", {0+1, 1+1});
134 double vmix_11 = src.get_val("VMIX", {1+1, 1+1});
135
136 double sw2 = src.get_val("WPARAM_SI_SM", 4);
137
138 double alphas_MSOFT = QCDHelper::alpha_s(2.448e3); //TODO better
139 double MSOFT = ParameterProxy(ParameterType::BSM).get_scale("MSOFT"); //TODO : better things to do with scale
140
141 std::cout << "MSOFT" << MSOFT << std::endl;
142
143 double factor = 2.0 / 3.0 * alphas_MSOFT / M_PI;
144
145 double M_2 = src.get_val("MSOFT", 2);
146
147
148 double term1 = (ad_22 / tan_beta - mu_Q) / m_gluino *
149 H2(m_bs * m_bs / m_gluino / m_gluino, m_b2s * m_b2s / m_gluino / m_gluino);
150 double term2 = -0.5 * (B(m_gluino, m_bs, MSOFT) + B(m_gluino, m_b2s, MSOFT)) / tan_beta;
151 double term3 = 1.0 / alpha_em / sw2 / 4.0 / M_PI * (mu_Q * M_2) *
152 (sbot_mix_00 * sbot_mix_00 * H2(M_2 * M_2 / m_bs / m_bs, mu_Q * mu_Q / m_bs / m_bs) / m_bs / m_bs / 2.0 +
153 sbot_mix_01 * sbot_mix_01 * H2(M_2 * M_2 / m_b2s / m_b2s, mu_Q * mu_Q / m_b2s / m_b2s) / m_b2s / m_b2s / 2.0);
154
155
156 double epsilon_0 = factor * (term1 + term2) + term3;
157
158
159 term1 = yu_22 * yu_22 / 16.0 / M_PI / M_PI *
160 (mu_Q / tan_beta - au_22) *
161 ((umix_01 * vmix_01 / m_c1 *
162 H2(m_ts * m_ts / m_c1 / m_c1, m_t2s * m_t2s / m_c1 / m_c1)) +
163 (umix_11 * vmix_11 / m_c2 *
164 H2(m_ts * m_ts / m_c2 / m_c2, m_t2s * m_t2s / m_c2 / m_c2)));
165
166 term2 = 1.0 / alpha_em / sw2 / 4.0 / M_PI * (mu_Q * M_2) *
167 ((stop_mix_00 * stop_mix_00 *
168 H2(M_2 * M_2 / m_ts / m_ts, mu_Q * mu_Q / m_ts / m_ts) / m_ts / m_ts) +
169 (stop_mix_01 * stop_mix_01*
170 H2(M_2 * M_2 / m_t2s / m_t2s, mu_Q * mu_Q / m_t2s / m_t2s) / m_t2s / m_t2s));
171
172 double epsilon_2 = term1 + term2;
173
174
175 //b
176 double epsilon_b = epsilon_0 + epsilon_2;
177
178 //bp
179 const int nb_neut = static_cast<int>(m_neutralino.size());
180
181
182 double epsilonbp = 2.0 / 3.0 * alphas_MSOFT / M_PI *
183 (ad_22/ tan_beta - mu_Q) / m_gluino *
184 (stop_mix_00 * stop_mix_00 * sbot_mix_00 * sbot_mix_00*
185 H2(m_ts * m_ts / m_gluino / m_gluino, m_b2s * m_b2s / m_gluino / m_gluino) +
186 stop_mix_00 * stop_mix_00 * sbot_mix_01 * sbot_mix_01 *
187 H2(m_ts * m_ts / m_gluino / m_gluino, m_bs * m_bs / m_gluino / m_gluino) +
188 stop_mix_01 * stop_mix_01 * sbot_mix_00 * sbot_mix_00 *
189 H2(m_t2s * m_t2s / m_gluino / m_gluino, m_b2s * m_b2s / m_gluino / m_gluino) +
190 stop_mix_01 * stop_mix_01 * sbot_mix_01 * sbot_mix_01 *
191 H2(m_t2s * m_t2s / m_gluino / m_gluino, m_bs * m_bs / m_gluino / m_gluino));
192
193 for(int ie = 0; ie < nb_neut; ++ie) {
194 epsilonbp += yu_22 * yu_22 / 16.0 / M_PI / M_PI *
195 src.get_val(neutralino_mix_block, {ie + 1, 3 + 1}) * src.get_val(neutralino_mix_block, {ie + 1, 2 + 1}) *
196 (au_22 - mu_Q / tan_beta) / m_neutralino[ie] *
197 (stop_mix_00 * stop_mix_00 * sbot_mix_00 * sbot_mix_00 *
198 H2(m_t2s * m_t2s / m_neutralino[ie] / m_neutralino[ie], m_bs * m_bs / m_neutralino[ie] / m_neutralino[ie]) +
199 stop_mix_00 * stop_mix_00 * sbot_mix_01 * sbot_mix_01 *
200 H2(m_t2s * m_t2s / m_neutralino[ie] / m_neutralino[ie], m_b2s * m_b2s / m_neutralino[ie] / m_neutralino[ie]) +
201 stop_mix_01 * stop_mix_01 * sbot_mix_00 * sbot_mix_00 *
202 H2(m_ts * m_ts / m_neutralino[ie] / m_neutralino[ie], m_bs * m_bs / m_neutralino[ie] / m_neutralino[ie]) +
203 stop_mix_01* stop_mix_01 * sbot_mix_01 * sbot_mix_01 *
204 H2(m_ts * m_ts / m_neutralino[ie] / m_neutralino[ie], m_b2s * m_b2s / m_neutralino[ie] / m_neutralino[ie]));
205 }
206
207 epsilonbp += 1.0 / alpha_em / sw2 / 4.0 / M_PI *
208 (mu_Q * M_2) *
209 ((stop_mix_00 * stop_mix_00 *
210 H2(M_2 * M_2 / m_ts / m_ts, mu_Q * mu_Q / m_ts / m_ts) / m_ts / m_ts +
211 stop_mix_01 * stop_mix_01 *
212 H2(M_2 * M_2 / m_t2s / m_t2s, mu_Q * mu_Q / m_t2s / m_t2s) / m_t2s / m_t2s) / 2.0 +
213 (sbot_mix_00 * sbot_mix_00 *
214 H2(M_2 * M_2 / m_bs / m_bs, mu_Q * mu_Q / m_bs / m_bs) / m_bs / m_bs +
215 sbot_mix_01 * sbot_mix_01 *
216 H2(M_2 * M_2 / m_b2s / m_b2s, mu_Q * mu_Q / m_b2s / m_b2s) / m_b2s / m_b2s));
217
218
219 double epsilon0p = -2.0 / 3.0 * alphas_MSOFT / M_PI *
220 (mu_Q + au_22 / tan_beta) / m_gluino *
221 (stop_mix_00 * stop_mix_00 *
222 H2(m_t2s * m_t2s / m_gluino / m_gluino, m_ss * m_ss / m_gluino / m_gluino) +
223 stop_mix_01 * stop_mix_01 *
224 H2(m_ts * m_ts / m_gluino / m_gluino, m_ss * m_ss / m_gluino / m_gluino));
225
226 for(int ie = 0; ie < nb_neut; ++ie) {
227 epsilon0p += yd_22 * yd_22 / 16.0 / M_PI / M_PI *
228 src.get_val(neutralino_mix_block, {ie+1, 3+1}) * src.get_val(neutralino_mix_block, {ie+1, 2+1}) *
229 (mu_Q / tan_beta) / m_neutralino[ie] *
230 (stop_mix_00 * stop_mix_00 * sbot_mix_00 * sbot_mix_00 *
231 H2(m_ts * m_ts / m_neutralino[ie] / m_neutralino[ie], m_b2s * m_b2s / m_neutralino[ie] / m_neutralino[ie]) +
232 stop_mix_00 * stop_mix_00 * sbot_mix_01 * sbot_mix_01 *
233 H2(m_ts * m_ts / m_neutralino[ie] / m_neutralino[ie], m_bs * m_bs / m_neutralino[ie] / m_neutralino[ie]) +
234 stop_mix_01 * stop_mix_01 * sbot_mix_00 * sbot_mix_00 *
235 H2(m_t2s * m_t2s / m_neutralino[ie] / m_neutralino[ie], m_b2s * m_b2s / m_neutralino[ie] / m_neutralino[ie]) +
236 stop_mix_01 * stop_mix_01 * sbot_mix_01* sbot_mix_01 *
237 H2(m_t2s * m_t2s / m_neutralino[ie] / m_neutralino[ie], m_bs * m_bs / m_neutralino[ie] / m_neutralino[ie]));
238
239 }
240
241 term1 = 1.0 / 16.0 / M_PI / M_PI *
242 (yd_22 * yd_22 * ad_22 / mu_Q *
243 H2(std::pow(mqL3 / mu_Q, 2), std::pow(mbR / mu_Q, 2)));
244
245 term2 = -g2 * g2 * M_2 / mu_Q *
246 H2(std::pow(mqL3 / mu_Q, 2), std::pow(M_2 / mu_Q, 2)) / 16.0 / M_PI / M_PI;
247
248 double epsilon_1p = term1 + term2;
249
250 double epsfac=pow((1.+epsilon_b*tan_beta),2.);
251
252 dep_block->store_or_assign({0,1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", {0,1}}, epsilon_0, 0., 0.));
253 dep_block->store_or_assign({0,2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", {0,2}}, epsilon0p, 0., 0.));
254 dep_block->store_or_assign(1, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", 1}, epsilon_1p, 0., 0.));
255 dep_block->store_or_assign(2, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", 2}, epsilon_2, 0., 0.));
256 dep_block->store_or_assign(3, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", 3}, epsilon_b, 0., 0.));
257 dep_block->store_or_assign(4, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", 4}, epsilonbp, 0., 0.));
258 dep_block->store_or_assign(5, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "EPSILON_SUSY", 5}, epsfac, 0., 0.));
259
260 };
261
262 iblock_c->compose_block("EPSILON_SUSY", src, func);
263}
264
265void SUSYParameterHelper::init_scale_independent_block(int) {
266
267 std::unordered_map<ParameterType, std::vector<std::string>> src = {{ParameterType::SM, {"MASS", "GAUGE", "VCKM"}}, {ParameterType::BSM, {"MASS", "HMIX", "STOPMIX", "USQMIX"}}};
268
269 auto func = [] (const BlockSrc& src, std::shared_ptr<DependentBlock> dep_block) {
270 double mW = src.get_val("MASS", 24);
271 double alphas_mg = QCDHelper::alpha_s(src.get_val("MASS", 1000021));
272 double ag = 1.0 - 7.0 / (12.0 * Pi) * alphas_mg;
273 double aY = 1.0 + alphas_mg / (4.0 * Pi);
274
275 double kappa = 1.0 / (pow(src.get_val("GAUGE", 2), 2.) *
276 std::real((src.get_val("VCKM", {2,2}))*(src.get_val("VCKM", {2,1})))); //VCKM 33 et 32
277 //ASK : careful with real
278
279 double kappaFactor = -0.5 * kappa;
280
281 double tanb = src.get_val("HMIX", 2);
282 double beta = std::atan(tanb);
283 double z = pow(src.get_val("MASS", 37) / mW, 2.);
284 double sinb = std::sin(std::atan(tanb));
285 double cosb = std::cos(std::atan(tanb));
286 double ct = src.get_val("STOPMIX", {2,2});
287 double st = src.get_val("STOPMIX", {1,2});
288
289 double lu = 1./tanb;
290 double ld = -tanb;
291
292 Array1D_4 ME = {src.get_val("MASS", 11), src.get_val("MASS", 13), src.get_val("MASS", 15)};
293
294 Array1D_3 Mch = {src.get_val("MASS", 1000024), src.get_val("MASS", 1000037)};
295
296 Array1D_7 MsqU = {src.get_val("MASS", 1000002), src.get_val("MASS", 1000004), src.get_val("MASS", 1000006),
297 src.get_val("MASS", 2000002), src.get_val("MASS", 2000004), src.get_val("MASS", 2000006)};
298
299 Array1D_7 MsqD = {src.get_val("MASS", 1000001), src.get_val("MASS", 1000003), src.get_val("MASS", 1000005),
300 src.get_val("MASS", 2000001), src.get_val("MASS", 2000003), src.get_val("MASS", 2000005)};
301
302 Array1D_4 Msn = {src.get_val("MASS", 1000012), src.get_val("MASS", 1000014), src.get_val("MASS", 1000016)};
303
304 const size_t NumSquarks = 6;
305 // Array2D_7x7 sU_mix; //ERROR
306 bool isNonZeroMix = true;
307
308 for (size_t j = 0; j < NumSquarks; ++j) {
309 // std::cout << "su : " << src.get_val("USQMIX", {1, j+1}) << std::endl;
310 if (src.get_val("USQMIX", {size_t(1), j+1}) == 0.0) {
311 isNonZeroMix = false;
312 break;
313 }
314 }
315
316 if (isNonZeroMix) {
317 std::sort(MsqU.begin(), MsqU.end());
318 }
319
320 dep_block->store_or_assign(1, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 1}, z, 0., 0.)); //1
321 dep_block->store_or_assign(2, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 2}, cosb, 0., 0.)); //2
322 dep_block->store_or_assign(3, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 3}, sinb, 0., 0.)); //3
323 dep_block->store_or_assign(4, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 4}, ct, 0., 0.)); //4
324 dep_block->store_or_assign(5, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 5}, st, 0., 0.)); //5
325 dep_block->store_or_assign(6, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 6}, beta, 0., 0.)); //6
326 dep_block->store_or_assign(7, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 7}, lu, 0., 0.)); //7
327 dep_block->store_or_assign(8, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 8}, ld, 0., 0.)); //8
328 dep_block->store_or_assign(9, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 9}, alphas_mg, 0., 0.)); //9
329 dep_block->store_or_assign(10, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 10}, ag, 0., 0.)); //10
330 dep_block->store_or_assign(11, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 11}, aY, 0., 0.)); //11
331 dep_block->store_or_assign({12, 0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{12, 0}}, ME[0], 0., 0.)); //12
332 dep_block->store_or_assign({12, 1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {12, 1}}, ME[1], 0., 0.)); //12
333 dep_block->store_or_assign({12, 2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {12, 2}}, ME[2], 0., 0.)); //12
334 dep_block->store_or_assign({13, 0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{13, 0}}, Mch[0], 0., 0.)); //13
335 dep_block->store_or_assign({13, 1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {13, 1}}, Mch[1], 0., 0.)); //13
336 dep_block->store_or_assign({14, 0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{14, 0}}, MsqU[0], 0., 0.)); //14
337 dep_block->store_or_assign({14, 1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{14, 1}}, MsqU[1], 0., 0.)); //14
338 dep_block->store_or_assign({14, 2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{14, 2}}, MsqU[2], 0., 0.)); //14
339 dep_block->store_or_assign({14, 3}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{14, 3}}, MsqU[3], 0., 0.)); //14
340 dep_block->store_or_assign({14, 4}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{14, 4}}, MsqU[4], 0., 0.)); //14
341 dep_block->store_or_assign({14, 5}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {14, 5}}, MsqU[5], 0., 0.)); //14
342 dep_block->store_or_assign({15, 0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{15, 0}}, MsqD[0], 0., 0.)); //15
343 dep_block->store_or_assign({15, 1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{15, 1}}, MsqD[1], 0., 0.)); //15
344 dep_block->store_or_assign({15, 2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{15, 2}}, MsqD[2], 0., 0.)); //15
345 dep_block->store_or_assign({15, 3}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{15, 3}}, MsqD[3], 0., 0.)); //15
346 dep_block->store_or_assign({15, 4}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{15, 4}}, MsqD[4], 0., 0.)); //15
347 dep_block->store_or_assign({15, 5}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {15, 5}}, MsqD[5], 0., 0.)); //15
348 dep_block->store_or_assign({16, 0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM",{16, 0}}, Msn[0], 0., 0.)); //16
349 dep_block->store_or_assign({16, 1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {16, 1}}, Msn[1], 0., 0.)); //16
350 dep_block->store_or_assign({16, 2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", {16, 2}}, Msn[2], 0., 0.)); //16
351 dep_block->store_or_assign(17, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 17}, (double)isNonZeroMix, 0., 0.)); //17
352 dep_block->store_or_assign(18, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 18}, kappaFactor, 0., 0.)); //18
353 dep_block->store_or_assign(19, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_SI_BSM", 19}, kappa, 0., 0.)); //19
354 };
355
356 iblock_c->compose_block("WPARAM_SI_BSM", src, func);
357
358
359}
360
361void SUSYParameterHelper::init_matching_block() {
362 std::unordered_map<ParameterType, std::vector<std::string>> src = {{ParameterType::SM, {"MASS"}}, {ParameterType::BSM, {"MASS"}},
363 {ParameterType::WILSON, {"WPARAM_MATCH_SM"}}};
364
365 auto func = [] (const BlockSrc& src, std::shared_ptr<DependentBlock> dep_block) {
366 double yt= pow(src.get_val("WPARAM_MATCH_SM", 6)/src.get_val("MASS", 37),2.); // param->mass_H (25)
367 Array1D_4 MU = {src.get_val("MASS", 2), src.get_val("MASS", 4), src.get_val("WPARAM_MATCH_SM", 6)}; //TODO : size 3 not 4
368 Array1D_4 MD = {src.get_val("MASS", 2), src.get_val("MASS", 3), src.get_val("WPARAM_MATCH_SM", {5,1})}; //TODO : size 3 not 4 // TODO : MD[0] -> mu like superiso but why ?
369
370 dep_block->store_or_assign(1, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", 1}, yt, 0., 0.));
371 dep_block->store_or_assign({2,0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {2,0}}, MU[0], 0., 0.));
372 dep_block->store_or_assign({2,1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {2,1}}, MU[1], 0., 0.));
373 dep_block->store_or_assign({2,2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {2,2}}, MU[2], 0., 0.));
374 dep_block->store_or_assign({3,0}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {3,0}}, MD[0], 0., 0.));
375 dep_block->store_or_assign({3,1}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {3,1}}, MD[1], 0., 0.));
376 dep_block->store_or_assign({3,2}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "WPARAM_MATCH_BSM", {3,2}}, MD[2], 0., 0.));
377
378 };
379
380 iblock_c->compose_block("WPARAM_MATCH_BSM", src, func);
381
382 std::unordered_map<ParameterType, std::vector<std::string>> src_matrix = {{ParameterType::SM, {"MASS", "VCKM", "GAUGE"}}, {ParameterType::BSM, {"UMIX", "VMIX", "USQMIX"}},
383 {ParameterType::WILSON, {"WPARAM_SI_BSM", "WPARAM_MATCH_SM", "WPARAM_MATCH_BSM"}}};
384
385 auto func_matrix = [] (const BlockSrc& src, std::shared_ptr<DependentBlock> dep_block) {
386
387 Array2D_7x4 Gamma_UL {};
388 Array2D_7x4 Gamma_UR {};
389 Array2D_4x4 Gamma_NL {};
390 Array2D_4x4 Gamma_NR {};
391 Array2D_7x7 Gamma_U{};
392 Array2D_7x7 I_LR{};
393 Array2D_7x7 P_U{};
394 Array3D_3x7x4 X_UL{};
395 Array3D_3x7x4 X_UR{};
396 Array3D_3x7x4 X_NL{};
397 Array3D_3x7x4 X_NR{};
398 std::array<std::array<std::array<std::array<double, 4>, 4>, 3>, 7> G_aimn;
399
400 complex_t c11 = src.get_val("VCKM", {0,0});
401 complex_t c12 = src.get_val("VCKM", {0,1});
402 complex_t c13 = src.get_val("VCKM", {0,2});
403 complex_t c21 = src.get_val("VCKM", {1,0});
404 complex_t c22 = src.get_val("VCKM", {1,1});
405 complex_t c23 = src.get_val("VCKM", {1,2});
406 complex_t c31 = src.get_val("VCKM", {2,0});
407 complex_t c32 = src.get_val("VCKM", {2,1});
408 complex_t c33 = src.get_val("VCKM", {2,2});
409
410
411 Array2D_4x4_I VCKM = {{
412 {
413 c11,
414 c12,
415 c13
416 },
417 {
418 c21,
419 c22,
420 c23
421 },
422 {
423 c31,
424 c32,
425 c33
426 }
427 }};
428
429 double B0c1 = 0.0, B0c2 = 0.0, B90c = 0.0, B100c = 0.0, C90c = 0.0, D90c = 0.0;
430
431 double mW = src.get_val("MASS", 24);
432 double g2 = src.get_val("GAUGE", 2);
433 if (src.get_val("WPARAM_SI_BSM", 17)) {
434 std::cout << "SHOULD NOT BE HERE" << std::endl;
435 const int NumSquarks = 6;
436 for (int ae = 0; ae < NumSquarks; ++ae) {
437 for (int ie = 0; ie < 3; ++ie) {
438
439 Gamma_UL[ae][ie] = src.get_val("USQMIX", {ae+1, ie+1});
440 Gamma_UR[ae][ie] = src.get_val("USQMIX", {ae+1, ie+3+1});
441
442 }
443 }
444 }
445 else {
446 Gamma_UL[0][0] = 1.0;
447 Gamma_UL[1][1] = 1.0;
448 Gamma_UL[2][2] = src.get_val("WPARAM_SI_BSM", 4);
449 Gamma_UL[5][2] = -src.get_val("WPARAM_SI_BSM", 5);
450
451 Gamma_UR[3][0] = 1.0;
452 Gamma_UR[4][1] = 1.0;
453 Gamma_UR[2][2] = src.get_val("WPARAM_SI_BSM", 5);
454 Gamma_UR[5][2] = src.get_val("WPARAM_SI_BSM", 4);
455 }
456
457 for (int ae = 0; ae < 6; ++ae) {
458 for (int ie = 0; ie < 3; ++ie) {
459 Gamma_U[ae][ie] = Gamma_UL[ae][ie];
460 Gamma_U[ae][ie+3] = Gamma_UR[ae][ie];
461 if (ae <3 && ae==ie) {
462 Gamma_NL[ae][ie] = 1.;
463 Gamma_NR[ae][ie] = 1.;
464 }
465 }
466 }
467
468 I_LR.fill({});
469 for (int i = 0; i < 3; ++i) {
470 I_LR[i][i] = 1.;
471 I_LR[i+3][i+3] = -1.;
472 }
473
474 for (int ae = 0; ae < 6; ++ae) {
475 for (int be = 0; be < 6; ++be) {
476 for (int ce = 0; ce < 6; ++ce) {
477 for (int de = 0; de < 6; ++de) {
478 P_U[ae][be] = Gamma_U[ae][ce] * I_LR[ce][de] * Gamma_U[be][de];
479 }
480 }
481 }
482
483 }
484
485 for (int ie = 0; ie < 2; ++ie) {
486 for (int ae = 0; ae < 6; ++ae) {
487 for (int be = 0; be < 3; ++be) {
488 X_UL[ie][ae][be] = 0.0;
489 X_UR[ie][ae][be] = 0.0;
490
491 for (int ce = 0; ce < 3; ++ce) {
492 X_UL[ie][ae][be] += -g2 * (
493 src.get_val("WPARAM_SI_BSM", 10) * src.get_val("VMIX", {ie+1, 0+1}) * Gamma_UL[ae][ce] -
494 src.get_val("WPARAM_SI_BSM", 11) * src.get_val("VMIX", {ie+1, 1+1}) * Gamma_UR[ae][ce] * src.get_val("WPARAM_MATCH_BSM", {2,ce}) / (sqrt(2.0) * mW * src.get_val("WPARAM_SI_BSM", 3))
495 ) * std::real(VCKM[ce][be]);
496 X_UR[ie][ae][be] += g2 * src.get_val("WPARAM_SI_BSM", 11) * src.get_val("UMIX", {ie+1, 1+1}) * Gamma_UL[ae][ce] * std::real(VCKM[ce][be]) * src.get_val("WPARAM_MATCH_BSM", {3,be}) / (sqrt(2.0) * mW * src.get_val("WPARAM_SI_BSM", 2));
497
498 G_aimn[ae][ie][be][ce]=0.5/sqrt(2.)*(sqrt(2.)*mW*src.get_val("VMIX", {ie+1, 0+1})*Gamma_UL[ae][ce]*src.get_val("WPARAM_SI_BSM", 10)-src.get_val("WPARAM_MATCH_BSM", {2,ce})*src.get_val("VMIX", {ie+1, 1+1})*Gamma_UR[ae][ce]*src.get_val("WPARAM_SI_BSM", 11))*(std::real(VCKM[be][2])*std::real(VCKM[ce][1])/std::real(VCKM[2][2])/std::real(VCKM[2][1]));
499 }
500
501 if (ae < 3) {
502 X_NL[ie][ae][be] = -g2 * src.get_val("VMIX", {ie+1, 0+1}) * Gamma_NL[ae][be];
503
504 X_NR[ie][ae][be] = g2 * src.get_val("UMIX", {ie+1, 1+1}) * Gamma_NL[ae][be] * src.get_val("WPARAM_SI_BSM", {12, be}) / (sqrt(2.0) * mW * src.get_val("WPARAM_SI_BSM", 2)); //12 -> ME
505 }
506
507 }
508 }
509 }
510
511
512
513 // double kappaFactor = -0.5 * src.get_val("WPARAM_SI_BSM", 6);
514
515
516 for (int ie = 0; ie < 2; ++ie) {
517 for (int je = 0; je < 2; ++je) {
518 for (int ae = 0; ae < 6; ++ae) {
519 double mchRatioSquared = pow(src.get_val("WPARAM_SI_BSM", {13, je}) / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0); //Mch : WPARAM_SI_BSM 13
520 double msqOverMchSquared = pow(src.get_val("WPARAM_SI_BSM", {14, ae}) / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0);
521
522 for (int be = 0; be < 3; ++be) {
523 double msnOverMchSquared = pow(src.get_val("WPARAM_SI_BSM", {16, be}) / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0);
524 B0c1 += X_UL[je][ae][1] * X_UL[ie][ae][2] / (src.get_val("WPARAM_SI_BSM", {13, ie}) * src.get_val("WPARAM_SI_BSM", {13, ie})) * (0.5 * X_NL[ie][be][1] * X_NL[je][be][1] * f50(mchRatioSquared, msqOverMchSquared, msnOverMchSquared));
525 B0c2 += X_UL[je][ae][1] * X_UL[ie][ae][2] / (src.get_val("WPARAM_SI_BSM", {13, ie}) * src.get_val("WPARAM_SI_BSM", {13, ie})) * (X_NR[ie][be][1] * X_NR[je][be][1] * std::fabs(src.get_val("WPARAM_SI_BSM", {13, je}) / src.get_val("WPARAM_SI_BSM", {13, ie})) * f60(mchRatioSquared, msqOverMchSquared, msnOverMchSquared));
526 }
527
528 C90c += X_UL[je][ae][1] * X_UL[ie][ae][2] * (2.0 * std::fabs(src.get_val("WPARAM_SI_BSM", {13, je}) / src.get_val("WPARAM_SI_BSM", {13, ie})) * f30(mchRatioSquared, msqOverMchSquared) * src.get_val("UMIX", {je+1, 0+1}) * src.get_val("UMIX", {ie+1,0+1}) - f40(mchRatioSquared, msqOverMchSquared) * src.get_val("VMIX", {je+1,0+1}) * src.get_val("VMIX", {ie+1,0+1}));
529
530 if (ie == je) {
531 D90c += pow(mW / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0) * X_UL[ie][ae][1] * X_UL[ie][ae][2] * h30(msqOverMchSquared);
532 }
533 }
534 }
535 }
536
537 for (int ie = 0; ie < 2; ++ie) {
538 for (int ae = 0; ae < 6; ++ae) {
539 for (int be = 0; be < 6; ++be) {
540 double msqOverMchSquaredAe = pow(src.get_val("WPARAM_SI_BSM", {14, ae}) / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0);
541 double msqOverMchSquaredBe = pow(src.get_val("WPARAM_SI_BSM", {14, be}) / src.get_val("WPARAM_SI_BSM", {13, ie}), 2.0);
542 for (int ce = 0; ce < 3; ++ce) {
543 C90c += X_UL[ie][be][1] * X_UL[ie][ae][2] * f40(msqOverMchSquaredAe, msqOverMchSquaredBe) * Gamma_UL[be][ce] * Gamma_UL[ae][ce];
544 }
545 }
546 }
547 }
548 B90c = -(B0c1 - B0c2) * src.get_val("WPARAM_SI_BSM", 19) * std::pow(mW, 2.0) / (2.0 * std::pow(g2, 2.0));
549 B100c = (B0c1 + B0c2) * src.get_val("WPARAM_SI_BSM", 19) * std::pow(mW, 2.0) / (2.0 * std::pow(g2, 2.0));
550 C90c *= -src.get_val("WPARAM_SI_BSM", 19) / 8.0;
551 D90c *= src.get_val("WPARAM_SI_BSM", 19);
552
553 //TODO : to check
554 // bool test = true;
555 // for (int ae = 0; ae < 6; ++ae) {
556 // if (!(std::fabs(src.get_val("WPARAM_SI_BSM", {14, ae})) > mW / 2. && std::fabs(src.get_val("WPARAM_SI_BSM", {15, ae})) > mW / 2.)) {
557 // test = false;
558 // break;
559 // }
560 // }
561
562
563 for (size_t i = 0; i < Gamma_UL.size(); ++i) {
564 for (size_t j = 0; j < Gamma_UL[i].size(); ++j) {
565 dep_block->store_or_assign({1,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {1,i,j}}, Gamma_UL[i][j], 0., 0.)); //1
566 dep_block->store_or_assign({2,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {2,i,j}}, Gamma_UR[i][j], 0., 0.)); //2
567 }
568 }
569
570 for (size_t i = 0; i < X_UL.size(); ++i) {
571 for (size_t j = 0; j < X_UL[i].size(); ++j) {
572 for (size_t k = 0; k < X_UL[i][j].size(); ++k) {
573 dep_block->store_or_assign({3,i,j,k}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {3,i,j,k}}, X_UL[i][j][k], 0., 0.)); //3
574 dep_block->store_or_assign({4,i,j,k}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {4,i,j,k}}, X_UR[i][j][k], 0., 0.)); //4
575 dep_block->store_or_assign({5,i,j,k}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {5,i,j,k}}, X_NL[i][j][k], 0., 0.)); //5
576 dep_block->store_or_assign({6,i,j,k}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {6,i,j,k}}, X_NR[i][j][k], 0., 0.)); //6
577 }
578 }
579 }
580
581 for (size_t i = 0; i < Gamma_U.size(); ++i) {
582 for (size_t j = 0; j < Gamma_U[i].size(); ++j) {
583 dep_block->store_or_assign({7,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {7,i,j}}, Gamma_U[i][j], 0., 0.)); //7
584 dep_block->store_or_assign({8,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {8,i,j}}, I_LR[i][j], 0., 0.)); //8
585 dep_block->store_or_assign({9,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {9,i,j}}, P_U[i][j], 0., 0.)); //9
586 }
587 }
588
589 for (size_t i = 0; i < Gamma_NL.size(); ++i) {
590 for (size_t j = 0; j < Gamma_NL[i].size(); ++j) {
591 dep_block->store_or_assign({10,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {10,i,j}}, Gamma_NL[i][j], 0., 0.)); //10
592 dep_block->store_or_assign({11,i,j}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {11,i,j}}, Gamma_NR[i][j], 0., 0.)); //11
593 }
594 }
595
596 for (size_t i = 0; i < G_aimn.size(); ++i) {
597 for (size_t j = 0; j < G_aimn[i].size(); ++j) {
598 for (size_t k = 0; k < G_aimn[i][j].size(); ++k) {
599 for (size_t l = 0; l < G_aimn[i][j][k].size(); ++l) {
600 dep_block->store_or_assign({12, i, j, k, l}, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", {12, i, j, k, l}}, G_aimn[i][j][k][l], 0., 0.)); //12
601 }
602 }
603 }
604 }
605
606 dep_block->store_or_assign(13, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", 13}, B90c, 0., 0.)); //13
607 dep_block->store_or_assign(14, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", 14}, C90c, 0., 0.)); //14
608 dep_block->store_or_assign(15, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", 15}, D90c, 0., 0.)); //15
609 dep_block->store_or_assign(16, std::make_shared<Parameter>(ParamId{ParameterType::WILSON, "MATRIX_BSM", 16}, B100c, 0., 0.)); //16
610 };
611
612 iblock_c->compose_block("MATRIX_BSM", src_matrix, func_matrix);
613}
MSOFT
const Prototype MSOFT
Definition LhaBlockPrototype.h:80
LOG_INFO
#define LOG_INFO(...)
Macro for logging informational messages.
Definition Logger.h:39
LOG_WARN
#define LOG_WARN(...)
Macro for logging warning messages.
Definition Logger.h:40
Parameters.h
Model-dependent parameter repository and initialization strategies.
SUSYParametersHelper.h
SUSY-specific implementation of IWilsonParameterHelper.
Array1D_4
std::array< double, 4 > Array1D_4
Definition SUSYParametersHelper.h:46
Array2D_7x4
std::array< std::array< double, M_UL_UR >, N_UL_UR > Array2D_7x4
Definition SUSYParametersHelper.h:42
Array2D_4x4_I
std::array< std::array< complex_t, M_NL_NR >, N_NL_NR > Array2D_4x4_I
Definition SUSYParametersHelper.h:49
Array2D_7x7
std::array< std::array< double, M_Gamma_U >, N_Gamma_U > Array2D_7x7
Definition SUSYParametersHelper.h:44
Pi
constexpr double Pi
Definition SUSYParametersHelper.h:38
Array1D_3
std::array< double, N_Mch > Array1D_3
Definition SUSYParametersHelper.h:47
Array3D_3x7x4
std::array< Array2D_7x4, N_X > Array3D_3x7x4
Definition SUSYParametersHelper.h:45
Array1D_7
std::array< double, N_MsqU > Array1D_7
Definition SUSYParametersHelper.h:48
Array2D_4x4
std::array< std::array< double, M_NL_NR >, N_NL_NR > Array2D_4x4
Definition SUSYParametersHelper.h:43
complex_t
std::complex< double > complex_t
Convenience alias for std::complex<double>.
Definition Utils.h:35
BlockSrc
Lightweight view over a set of source blocks.
Definition SourcesView.h:71
IWilsonParameterHelper::initialized
bool initialized
Tracks whether the helper has already been initialized.
Definition IWilsonParameters.h:88
IWilsonParameterHelper::iblock_c
std::shared_ptr< IBlockComposer > iblock_c
Block composer (dependency engine) used to register dependent blocks.
Definition IWilsonParameters.h:85
ParameterProxy
Parameter access proxy bound to a specific ParameterType.
Definition ParameterProxy.h:41
ParameterProxy::get_scale
double get_scale(const std::string &block) const override
Returns the block scale.
Definition ParameterProxy.cpp:22
Parameters::GetInstance
static std::shared_ptr< Parameters > GetInstance(ParameterType id=ParameterType::SM)
Returns the singleton-like repository for a given parameter type.
Definition Parameters.cpp:11
QCDHelper::alpha_s
static double alpha_s(double mu, MassType mass_b_type=MassType::POLE, MassType mass_t_type=MassType::POLE)
Computes the strong coupling constant α_s at scale μ.
Definition QCDHelper.cpp:52
SUSYParameterHelper::init_scale_independent_block
void init_scale_independent_block(int gen) override
Builds SUSY scale-independent helper blocks.
Definition SUSYParametersHelper.cpp:265
SUSYParameterHelper::init_matching_block
void init_matching_block() override
Builds SUSY matching-scale helper blocks.
Definition SUSYParametersHelper.cpp:361
SUSYParameterHelper::init
void init(int gen, WGroupId grp) override
Initializes SUSY-specific helper blocks.
Definition SUSYParametersHelper.cpp:5
SymbolId
Returns an uppercase copy of the input string.
Definition dynamic_registry.h:47
scalar_t
Definition scalar.h:11
pow
scalar_t pow(const scalar_t &base, const scalar_t &exp)
Definition scalar.cpp:75
H2
double H2(double x, double y)
Computes the two-variable function H2(x, y).
Definition special_SM.cpp:901
f40
double f40(double x, double y)
Definition special_SM.cpp:122
f30
double f30(double x, double y)
Definition special_SM.cpp:108
f60
double f60(double x, double y, double z)
Definition special_SM.cpp:159
h30
double h30(double x)
Definition special_SM.cpp:62
f50
double f50(double x, double y, double z)
Definition special_SM.cpp:136
LhaID
Represents an identifier of a LHA element, possibly containing several sub-ids.
Definition LhaID.h:56
ParamId
Composite identifier for a single parameter.
Definition ParamID.h:57