cepgen is hosted by Hepforge, IPPP Durham
CepGen 1.2.5
Central exclusive processes event generator
Loading...
Searching...
No Matches
ALLM.cpp
Go to the documentation of this file.
1/*
2 * CepGen: a central exclusive processes event generator
3 * Copyright (C) 2017-2024 Laurent Forthomme
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19#include <cassert>
20#include <cmath>
21
22#include "CepGen/Core/Exception.h"
23#include "CepGen/Core/SteeredObject.h"
24#include "CepGen/Modules/StructureFunctionsFactory.h"
25#include "CepGen/Physics/Utils.h"
26#include "CepGen/StructureFunctions/Parameterisation.h"
27
28namespace cepgen {
29 namespace strfun {
31 class ALLM : public Parameterisation {
32 public:
33 explicit ALLM(const ParametersList&);
34
35 static ParametersDescription description() {
36 auto desc = Parameterisation::description();
37 desc.setDescription("Abramowicz, Levin, Levy, and Maor (continuum)");
38 desc.add<ParametersDescription>("pomeronTrajectory", Trajectory::description());
39 desc.add<ParametersDescription>("reggeonTrajectory", Trajectory::description());
40 desc.add<double>("m02", 0.).setDescription("effective photon squared mass (in GeV^2)");
41 desc.add<double>("mp2", 0.).setDescription("effective pomeron squared mass (in GeV^2)");
42 desc.add<double>("mr2", 0.).setDescription("effective reggeon squared mass (in GeV^2)");
43 desc.add<double>("q02", 0.);
44 desc.add<double>("lambda2", 0.).setDescription("squared QCD scale (in GeV^2");
45 return desc;
46 }
47
48 void eval() override;
49
50 private:
51 class Trajectory : public SteeredObject<Trajectory> {
52 public:
53 explicit Trajectory(const ParametersList& params)
54 : SteeredObject(params),
55 a_(steer<std::vector<double> >("a")),
56 b_(steer<std::vector<double> >("b")),
57 c_(steer<std::vector<double> >("c")) {
58 assert(a_.size() == 3);
59 assert(b_.size() == 3);
60 assert(c_.size() == 3);
61 }
62
63 static ParametersDescription description() {
64 auto desc = ParametersDescription();
65 desc.add<std::vector<double> >("a", {0., 0., 0.});
66 desc.add<std::vector<double> >("b", {0., 0., 0.});
67 desc.add<std::vector<double> >("c", {0., 0., 0.});
68 return desc;
69 }
70
71 friend std::ostream& operator<<(std::ostream& os, const Trajectory& tr) {
72 auto print_vec = [](const auto& vec) -> std::string {
73 std::ostringstream os;
74 std::string sep;
75 for (const auto& it : vec)
76 os << sep << it, sep = ", ";
77 return os.str();
78 };
79 return os << "[a = " << print_vec(tr.a_) << ", b = " << print_vec(tr.b_) << ", c = " << print_vec(tr.c_)
80 << "]";
81 }
82
83 double eval1(char mod, double t) const {
84 const auto& par = get(mod);
85 return par.at(0) + (par.at(0) - par.at(1)) * (1. / (1. + pow(t, par.at(2))) - 1.);
86 }
87 double eval2(char mod, double t) const {
88 const auto& par = get(mod);
89 return par.at(0) + par.at(1) * pow(t, par.at(2));
90 }
91
92 private:
93 const std::vector<double>& get(char mod) const {
94 switch (mod) {
95 case 'a':
96 return a_;
97 case 'b':
98 return b_;
99 case 'c':
100 return c_;
101 default:
102 throw CG_FATAL("ALLM:Trajectory") << "Failed to retrieve parameterisation for char{'" << mod << "'}!";
103 }
104 }
105 std::vector<double> a_, b_, c_;
106 };
107 Trajectory pomeron_, reggeon_;
109 double m02_;
111 double mpom2_;
113 double mreg2_;
114 double q02_;
116 double lambda2_;
117 };
118
119 ALLM::ALLM(const ParametersList& params)
120 : Parameterisation(params),
121 pomeron_(steer<ParametersList>("pomeronTrajectory")),
122 reggeon_(steer<ParametersList>("reggeonTrajectory")),
123 m02_(steer<double>("m02")),
124 mpom2_(steer<double>("mp2")),
125 mreg2_(steer<double>("mr2")),
126 q02_(steer<double>("q02")),
127 lambda2_(steer<double>("lambda2")) {
128 CG_DEBUG("ALLM") << "ALLM structure functions builder initialised.\n"
129 << " *) Pomeron trajectory: " << pomeron_ << "\n"
130 << " *) Reggeon trajectory: " << reggeon_ << "\n"
131 << " masses: m_0^2=" << m02_ << ", m_p^2=" << mpom2_ << ", m_r^2=" << mreg2_ << " GeV^2\n"
132 << " q_0^2=" << q02_ << ", Lambda^2=" << lambda2_ << " GeV^2.";
133 }
134
135 void ALLM::eval() {
136 const double w2_eff = utils::mX2(args_.xbj, args_.q2, mp2_) - mp2_;
137 const double xp = (args_.q2 + mpom2_) / (args_.q2 + w2_eff + mpom2_),
138 xr = (args_.q2 + mreg2_) / (args_.q2 + w2_eff + mreg2_);
139
140 const double xlog1 = log((args_.q2 + q02_) / lambda2_), xlog2 = log(q02_ / lambda2_);
141 const double t = log(xlog1 / xlog2);
142
143 const double apom = pomeron_.eval1('a', t), bpom = pomeron_.eval2('b', t), cpom = pomeron_.eval1('c', t);
144 const double areg = reggeon_.eval2('a', t), breg = reggeon_.eval2('b', t), creg = reggeon_.eval2('c', t);
145
146 const double F2_Pom = cpom * pow(xp, apom) * pow(1. - args_.xbj, bpom),
147 F2_Reg = creg * pow(xr, areg) * pow(1. - args_.xbj, breg);
148
149 setF2(args_.q2 / (args_.q2 + m02_) * (F2_Pom + F2_Reg));
150 }
151
152 //---------------------------------------------------------------------------------------------
153 // ALLM parameterisations
154 //---------------------------------------------------------------------------------------------
155
157 struct ALLM91 final : public ALLM {
158 using ALLM::ALLM;
159 static ParametersDescription description() {
160 auto desc = ALLM::description();
161 desc.setDescription("ALLM91 (continuum, pre-HERA 694 points fit)");
162 ParametersDescription pom_params;
163 pom_params.add<std::vector<double> >("a", {-0.04503, -0.36407, 8.17091});
164 pom_params.add<std::vector<double> >("b", {0.49222, 0.52116, 3.5515});
165 pom_params.add<std::vector<double> >("c", {0.26550, 0.04856, 1.04682});
166 desc.add("pomeronTrajectory", pom_params);
167 ParametersDescription reg_params;
168 reg_params.add<std::vector<double> >("a", {0.60408, 0.17353, 1.61812});
169 reg_params.add<std::vector<double> >("b", {1.26066, 1.83624, 0.81141});
170 reg_params.add<std::vector<double> >("c", {0.67639, 0.49027, 2.66275});
171 desc.add("reggeonTrajectory", reg_params);
172 desc.add<double>("m02", 0.30508);
173 desc.add<double>("mp2", 10.676);
174 desc.add<double>("mr2", 0.20623);
175 desc.add<double>("q02", 0.27799);
176 desc.add<double>("lambda2", 0.06527);
177 return desc;
178 }
179 };
180
182 struct ALLM97 final : public ALLM {
183 using ALLM::ALLM;
184 static ParametersDescription description() {
185 auto desc = ALLM::description();
186 desc.setDescription("ALLM97 (continuum, FT/HERA photoprod. tot.x-s 1356 points fit)");
187 ParametersDescription pom_params;
188 pom_params.add<std::vector<double> >("a", {-0.0808, -0.44812, 1.1709});
189 pom_params.add<std::vector<double> >("b", {0.36292, 1.8917, 1.8439});
190 pom_params.add<std::vector<double> >("c", {0.28067, 0.22291, 2.1979});
191 desc.add("pomeronTrajectory", pom_params);
192 ParametersDescription reg_params;
193 reg_params.add<std::vector<double> >("a", {0.58400, 0.37888, 2.6063});
194 reg_params.add<std::vector<double> >("b", {0.01147, 3.7582, 0.49338});
195 reg_params.add<std::vector<double> >("c", {0.80107, 0.97307, 3.4924});
196 desc.add("reggeonTrajectory", reg_params);
197 desc.add<double>("m02", 0.31985);
198 desc.add<double>("mp2", 49.457);
199 desc.add<double>("mr2", 0.15052);
200 desc.add<double>("q02", 0.52544);
201 desc.add<double>("lambda2", 0.06526);
202 return desc;
203 }
204 };
205
206 struct HHTALLM final : public ALLM {
207 using ALLM::ALLM;
208 static ParametersDescription description() {
209 auto desc = ALLM::description();
210 desc.setDescription("HHT (continuum)");
211 ParametersDescription pom_params;
212 pom_params.add<std::vector<double> >("a", {-0.835, -0.446, 10.6});
213 pom_params.add<std::vector<double> >("b", {-45.8, 55.7, -0.031});
214 pom_params.add<std::vector<double> >("c", {0.412, 0.164, 17.7});
215 desc.add("pomeronTrajectory", pom_params);
216 ParametersDescription reg_params;
217 reg_params.add<std::vector<double> >("a", {0.706, 0.185, -16.4});
218 reg_params.add<std::vector<double> >("b", {-1.29, 4.51, 1.16});
219 reg_params.add<std::vector<double> >("c", {-1.04, 2.97, 0.163});
220 desc.add("reggeonTrajectory", reg_params);
221 desc.add<double>("m02", 0.446);
222 desc.add<double>("mp2", 74.2);
223 desc.add<double>("mr2", 29.3);
224 desc.add<double>("q02", 4.74e-5);
225 desc.add<double>("lambda2", 2.2e-8);
226 return desc;
227 }
228 };
229
230 struct HHTALLMFT final : public ALLM {
231 using ALLM::ALLM;
232 static ParametersDescription description() {
233 auto desc = ALLM::description();
234 desc.setDescription("HHT_FT (continuum)");
235 ParametersDescription pom_params;
236 pom_params.add<std::vector<double> >("a", {-0.075, -0.470, 9.2});
237 pom_params.add<std::vector<double> >("b", {-0.477, 54.0, 0.073});
238 pom_params.add<std::vector<double> >("c", {0.356, 0.171, 18.6});
239 desc.add("pomeronTrajectory", pom_params);
240 ParametersDescription reg_params;
241 reg_params.add<std::vector<double> >("a", {0.882, 0.082, -8.5});
242 reg_params.add<std::vector<double> >("b", {0.339, 3.38, 1.07});
243 reg_params.add<std::vector<double> >("c", {-0.636, 3.37, -0.660});
244 desc.add("reggeonTrajectory", reg_params);
245 desc.add<double>("m02", 0.388);
246 desc.add<double>("mp2", 50.8);
247 desc.add<double>("mr2", 0.838);
248 desc.add<double>("q02", 1.87e-5);
249 desc.add<double>("lambda2", 4.4e-9);
250 return desc;
251 }
252 };
253
254 struct GD07p final : public ALLM {
255 using ALLM::ALLM;
256 static ParametersDescription description() {
257 auto desc = ALLM::description();
258 desc.setDescription("GD07p (continuum)");
259 ParametersDescription pom_params;
260 pom_params.add<std::vector<double> >("a", {-0.105, -0.495, 1.29});
261 pom_params.add<std::vector<double> >("b", {-1.42, 4.51, 0.551});
262 pom_params.add<std::vector<double> >("c", {0.339, 0.127, 1.16});
263 desc.add("pomeronTrajectory", pom_params);
264 ParametersDescription reg_params;
265 reg_params.add<std::vector<double> >("a", {0.374, 0.998, 0.775});
266 reg_params.add<std::vector<double> >("b", {2.71, 1.83, 1.26});
267 reg_params.add<std::vector<double> >("c", {0.838, 2.36, 1.77});
268 desc.add("reggeonTrajectory", reg_params);
269 desc.add<double>("m02", 0.454);
270 desc.add<double>("mp2", 30.7);
271 desc.add<double>("mr2", 0.117);
272 desc.add<double>("q02", 1.15);
273 desc.add<double>("lambda2", 0.06527);
274 return desc;
275 }
276 };
277
278 struct GD11p final : public ALLM {
279 using ALLM::ALLM;
280 static ParametersDescription description() {
281 auto desc = ALLM::description();
282 desc.setDescription("GD11p (continuum)");
283 ParametersDescription pom_params;
284 pom_params.add<std::vector<double> >("a", {-0.11895, -0.4783, 1.353});
285 pom_params.add<std::vector<double> >("b", {1.0833, 2.656, 1.771});
286 pom_params.add<std::vector<double> >("c", {0.3638, 0.1211, 1.166});
287 desc.add("pomeronTrajectory", pom_params);
288 ParametersDescription reg_params;
289 reg_params.add<std::vector<double> >("a", {0.3425, 1.0603, 0.5164});
290 reg_params.add<std::vector<double> >("b", {-10.408, 14.857, 0.07739});
291 reg_params.add<std::vector<double> >("c", {1.3633, 2.256, 2.209});
292 desc.add("reggeonTrajectory", reg_params);
293 desc.add<double>("m02", 0.5063);
294 desc.add<double>("mp2", 34.75);
295 desc.add<double>("mr2", 0.03190);
296 desc.add<double>("q02", 1.374);
297 desc.add<double>("lambda2", 0.06527);
298 return desc;
299 }
300 };
301 } // namespace strfun
302} // namespace cepgen
303using cepgen::strfun::ALLM91;
304using cepgen::strfun::ALLM97;
305using cepgen::strfun::GD07p;
306using cepgen::strfun::GD11p;
307using cepgen::strfun::HHTALLM;
308using cepgen::strfun::HHTALLMFT;
309REGISTER_STRFUN("ALLM91", 201, ALLM91);
310REGISTER_STRFUN("ALLM97", 202, ALLM97);
311REGISTER_STRFUN("GD07p", 203, GD07p);
312REGISTER_STRFUN("GD11p", 204, GD11p);
313REGISTER_STRFUN("htALLM", 206, HHTALLM);
314REGISTER_STRFUN("htALLMft", 207, HHTALLMFT);
CG_FATAL
#define CG_FATAL(mod)
Definition Exception.h:61
CG_DEBUG
#define CG_DEBUG(mod)
Definition Message.h:220
REGISTER_STRFUN
#define REGISTER_STRFUN(name, id, obj)
Add a structure functions definition to the list of handled parameterisation.
Definition StructureFunctionsFactory.h:25
cepgen::ParametersDescription
A description object for parameters collection.
Definition ParametersDescription.h:26
cepgen::ParametersDescription::add
ParametersDescription & add(const std::string &name, const T &def)
Add the description to a new parameter.
Definition ParametersDescription.h:59
cepgen::Steerable::steer
T steer(const std::string &key) const
Retrieve a parameters as previously steered.
Definition Steerable.h:39
cepgen::SteeredObject
Base user-steerable object.
Definition SteeredObject.h:41
cepgen::strfun::ALLM
parameterisation by Abramowicz, Levin, Levy, and Maor
Definition ALLM.cpp:31
cepgen::strfun::ALLM::description
static ParametersDescription description()
Definition ALLM.cpp:35
cepgen::strfun::ALLM::eval
void eval() override
Local structure functions evaluation method.
Definition ALLM.cpp:135
cepgen::strfun::ALLM::ALLM
ALLM(const ParametersList &)
Definition ALLM.cpp:119
cepgen::strfun::Parameterisation
Base object for the parameterisation of nucleon structure functions.
Definition Parameterisation.h:30
cepgen::strfun::Parameterisation::args_
Arguments args_
Last couple computed.
Definition Parameterisation.h:109
cepgen::strfun::Parameterisation::setF2
Parameterisation & setF2(double f2)
Definition Parameterisation.cpp:83
cepgen::strfun::Parameterisation::mp2_
const double mp2_
Squared proton mass, in GeV^2/c^4.
Definition Parameterisation.h:106
cepgen::strfun::Parameterisation::description
static ParametersDescription description()
Generic description for the structure functions.
Definition Parameterisation.cpp:148
cepgen::utils::env::get
std::string get(const std::string &var, const std::string &def)
Get an environment variable.
Definition Environment.cpp:28
cepgen::utils::mX2
double mX2(double xbj, double q2, double mp2)
Compute the diffractive mass from virtuality/Bjorken x.
Definition Utils.cpp:29
cepgen
Common namespace for this Monte Carlo generator.
Definition CommandLineHandler.cpp:36
cepgen::operator<<
std::ostream & operator<<(std::ostream &os, const Exception::Type &type)
Definition Exception.cpp:59
cepgen::strfun::ALLM91
Pre-HERA data fit (694 data points)
Definition ALLM.cpp:157
cepgen::strfun::ALLM91::description
static ParametersDescription description()
Definition ALLM.cpp:159
cepgen::strfun::ALLM97
Fixed target and HERA photoproduction total cross sections (1356 points)
Definition ALLM.cpp:182
cepgen::strfun::ALLM97::description
static ParametersDescription description()
Definition ALLM.cpp:184
cepgen::strfun::GD07p::description
static ParametersDescription description()
Definition ALLM.cpp:256
cepgen::strfun::GD11p::description
static ParametersDescription description()
Definition ALLM.cpp:280
cepgen::strfun::HHTALLMFT::description
static ParametersDescription description()
Definition ALLM.cpp:232
cepgen::strfun::HHTALLM::description
static ParametersDescription description()
Definition ALLM.cpp:208