]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id: AliGenEMlib.cxx 30052 2008-11-25 14:54:18Z morsch $ */ | |
17 | ||
18 | ///////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Implementation of AliGenEMlib for electron, di-electron, and photon // | |
21 | // cocktail calculations. // | |
22 | // It is based on AliGenGSIlib. // | |
23 | // // | |
24 | // Responsible: R.Averbeck@gsi.de // | |
25 | // // | |
26 | ///////////////////////////////////////////////////////////////////////////// | |
27 | ||
28 | ||
29 | #include "TMath.h" | |
30 | #include "TRandom.h" | |
31 | #include "TString.h" | |
32 | #include "AliGenEMlib.h" | |
33 | ||
34 | ||
35 | ClassImp(AliGenEMlib) | |
36 | ||
37 | //========================================================================== | |
38 | // | |
39 | // Definition of Particle Distributions | |
40 | // | |
41 | //========================================================================== | |
42 | ||
43 | //-------------------------------------------------------------------------- | |
44 | // | |
45 | // Pizero | |
46 | // | |
47 | //-------------------------------------------------------------------------- | |
48 | Int_t AliGenEMlib::IpPizero(TRandom *) | |
49 | { | |
50 | // Return pizero pdg code | |
51 | return 111; | |
52 | } | |
53 | ||
54 | Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ ) | |
55 | { | |
56 | // Generate pizero pT distribution from modified Hagedorn parameterization | |
57 | // taken from fit to unidentified hadrons in pp at 7 TeV | |
58 | const Double_t kc=0.000565; | |
59 | const Double_t kp0=0.2472; | |
60 | const Double_t kp1=4.354; | |
61 | const Double_t kn=7.007; | |
62 | Double_t invYield; | |
63 | Double_t x=*px; | |
64 | ||
65 | invYield = kc/TMath::Power(kp0+x/kp1,kn); | |
66 | ||
67 | return invYield*(2*TMath::Pi()*x); | |
68 | ||
69 | } | |
70 | ||
71 | Double_t AliGenEMlib::YPizero( const Double_t *py, const Double_t */*dummy*/ ) | |
72 | { | |
73 | return YFlat(*py); | |
74 | ||
75 | } | |
76 | ||
77 | //-------------------------------------------------------------------------- | |
78 | // | |
79 | // Eta | |
80 | // | |
81 | //-------------------------------------------------------------------------- | |
82 | Int_t AliGenEMlib::IpEta(TRandom *) | |
83 | { | |
84 | // Return eta pdg code | |
85 | return 221; | |
86 | } | |
87 | ||
88 | Double_t AliGenEMlib::PtEta( const Double_t *px, const Double_t */*dummy*/ ) | |
89 | { | |
90 | // Eta pT | |
91 | return MtScal(*px,2); | |
92 | } | |
93 | ||
94 | Double_t AliGenEMlib::YEta( const Double_t *py, const Double_t */*dummy*/ ) | |
95 | { | |
96 | return YFlat(*py); | |
97 | ||
98 | } | |
99 | ||
100 | //-------------------------------------------------------------------------- | |
101 | // | |
102 | // Rho | |
103 | // | |
104 | //-------------------------------------------------------------------------- | |
105 | Int_t AliGenEMlib::IpRho(TRandom *) | |
106 | { | |
107 | // Return rho pdg code | |
108 | return 113; | |
109 | } | |
110 | ||
111 | Double_t AliGenEMlib::PtRho( const Double_t *px, const Double_t */*dummy*/ ) | |
112 | { | |
113 | // Rho pT | |
114 | return MtScal(*px,3); | |
115 | } | |
116 | ||
117 | Double_t AliGenEMlib::YRho( const Double_t *py, const Double_t */*dummy*/ ) | |
118 | { | |
119 | return YFlat(*py); | |
120 | ||
121 | } | |
122 | ||
123 | //-------------------------------------------------------------------------- | |
124 | // | |
125 | // Omega | |
126 | // | |
127 | //-------------------------------------------------------------------------- | |
128 | Int_t AliGenEMlib::IpOmega(TRandom *) | |
129 | { | |
130 | // Return omega pdg code | |
131 | return 223; | |
132 | } | |
133 | ||
134 | Double_t AliGenEMlib::PtOmega( const Double_t *px, const Double_t */*dummy*/ ) | |
135 | { | |
136 | // Omega pT | |
137 | return MtScal(*px,4); | |
138 | } | |
139 | ||
140 | Double_t AliGenEMlib::YOmega( const Double_t *py, const Double_t */*dummy*/ ) | |
141 | { | |
142 | return YFlat(*py); | |
143 | ||
144 | } | |
145 | ||
146 | //-------------------------------------------------------------------------- | |
147 | // | |
148 | // Etaprime | |
149 | // | |
150 | //-------------------------------------------------------------------------- | |
151 | Int_t AliGenEMlib::IpEtaprime(TRandom *) | |
152 | { | |
153 | // Return etaprime pdg code | |
154 | return 331; | |
155 | } | |
156 | ||
157 | Double_t AliGenEMlib::PtEtaprime( const Double_t *px, const Double_t */*dummy*/ ) | |
158 | { | |
159 | // Eta pT | |
160 | return MtScal(*px,5); | |
161 | } | |
162 | ||
163 | Double_t AliGenEMlib::YEtaprime( const Double_t *py, const Double_t */*dummy*/ ) | |
164 | { | |
165 | return YFlat(*py); | |
166 | ||
167 | } | |
168 | ||
169 | //-------------------------------------------------------------------------- | |
170 | // | |
171 | // Phi | |
172 | // | |
173 | //-------------------------------------------------------------------------- | |
174 | Int_t AliGenEMlib::IpPhi(TRandom *) | |
175 | { | |
176 | // Return phi pdg code | |
177 | return 333; | |
178 | } | |
179 | ||
180 | Double_t AliGenEMlib::PtPhi( const Double_t *px, const Double_t */*dummy*/ ) | |
181 | { | |
182 | // Phi pT | |
183 | return MtScal(*px,6); | |
184 | } | |
185 | ||
186 | Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ ) | |
187 | { | |
188 | return YFlat(*py); | |
189 | ||
190 | } | |
191 | ||
192 | Double_t AliGenEMlib::YFlat(Double_t y) | |
193 | { | |
194 | //-------------------------------------------------------------------------- | |
195 | // | |
196 | // flat rapidity distribution | |
197 | // | |
198 | //-------------------------------------------------------------------------- | |
199 | ||
200 | Double_t dNdy = 1.; | |
201 | ||
202 | return dNdy; | |
203 | ||
204 | } | |
205 | ||
206 | //============================================================= | |
207 | // | |
208 | // Mt-scaling | |
209 | // | |
210 | //============================================================= | |
211 | // | |
212 | Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np) | |
213 | { | |
214 | // Function for the calculation of the Pt distribution for a | |
215 | // given particle np, from the pizero Pt distribution using | |
216 | // mt scaling. | |
217 | ||
218 | // MASS 1=>PIZERO, 2=>ETA, 3=>RHO, 4=>OMEGA, 5=>ETAPRIME, 6=>PHI | |
219 | ||
220 | const Double_t khm[6] = {0.13498, 0.54751, 0.7755, 0.78265, 0.95778, 1.01946}; | |
221 | np--; | |
222 | ||
223 | Double_t scaledPt = sqrt(pt*pt + khm[np]*khm[np] - khm[0]*khm[0]); | |
224 | Double_t scaledYield = PtPizero(&scaledPt, (Double_t*) 0); | |
225 | ||
226 | // VALUE MESON/PI AT 5 GEV | |
227 | ||
228 | Double_t normPt = 5.; | |
229 | Double_t scaledNormPt = sqrt(normPt*normPt + khm[np]*khm[np] - khm[0]*khm[0]); | |
230 | const Double_t kfmax[6]={1., 0.48, 1.0, 0.9, 0.25, 0.4}; | |
231 | ||
232 | Double_t norm = kfmax[np] * (PtPizero(&normPt, (Double_t*) 0) / PtPizero(&scaledNormPt, (Double_t*) 0)); | |
233 | ||
234 | return norm*(pt/scaledPt)*scaledYield; | |
235 | } | |
236 | ||
237 | //========================================================================== | |
238 | // | |
239 | // Set Getters | |
240 | // | |
241 | //========================================================================== | |
242 | ||
243 | typedef Double_t (*GenFunc) (const Double_t*, const Double_t*); | |
244 | ||
245 | typedef Int_t (*GenFuncIp) (TRandom *); | |
246 | ||
247 | GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const | |
248 | { | |
249 | // Return pointer to pT parameterisation | |
250 | GenFunc func=0; | |
251 | TString sname(tname); | |
252 | ||
253 | switch (param) | |
254 | { | |
255 | case kPizero: | |
256 | func=PtPizero; | |
257 | break; | |
258 | case kEta: | |
259 | func=PtEta; | |
260 | break; | |
261 | case kRho: | |
262 | func=PtRho; | |
263 | break; | |
264 | case kOmega: | |
265 | func=PtOmega; | |
266 | break; | |
267 | case kEtaprime: | |
268 | func=PtEtaprime; | |
269 | break; | |
270 | case kPhi: | |
271 | func=PtPhi; | |
272 | break; | |
273 | ||
274 | default: | |
275 | func=0; | |
276 | printf("<AliGenEMlib::GetPt> unknown parametrisation\n"); | |
277 | } | |
278 | return func; | |
279 | } | |
280 | ||
281 | GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const | |
282 | { | |
283 | // Return pointer to y- parameterisation | |
284 | GenFunc func=0; | |
285 | TString sname(tname); | |
286 | ||
287 | switch (param) | |
288 | { | |
289 | case kPizero: | |
290 | func=YPizero; | |
291 | break; | |
292 | case kEta: | |
293 | func=YEta; | |
294 | break; | |
295 | case kRho: | |
296 | func=YRho; | |
297 | break; | |
298 | case kOmega: | |
299 | func=YOmega; | |
300 | break; | |
301 | case kEtaprime: | |
302 | func=YEtaprime; | |
303 | break; | |
304 | case kPhi: | |
305 | func=YPhi; | |
306 | break; | |
307 | ||
308 | default: | |
309 | func=0; | |
310 | printf("<AliGenEMlib::GetY> unknown parametrisation\n"); | |
311 | } | |
312 | return func; | |
313 | } | |
314 | ||
315 | GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const | |
316 | { | |
317 | // Return pointer to particle type parameterisation | |
318 | GenFuncIp func=0; | |
319 | TString sname(tname); | |
320 | ||
321 | switch (param) | |
322 | { | |
323 | case kPizero: | |
324 | func=IpPizero; | |
325 | break; | |
326 | case kEta: | |
327 | func=IpEta; | |
328 | break; | |
329 | case kRho: | |
330 | func=IpRho; | |
331 | break; | |
332 | case kOmega: | |
333 | func=IpOmega; | |
334 | break; | |
335 | case kEtaprime: | |
336 | func=IpEtaprime; | |
337 | break; | |
338 | case kPhi: | |
339 | func=IpPhi; | |
340 | break; | |
341 | ||
342 | default: | |
343 | func=0; | |
344 | printf("<AliGenEMlib::GetIp> unknown parametrisation\n"); | |
345 | } | |
346 | return func; | |
347 | } | |
348 | ||
349 | ||
350 | ||
351 | ||
352 | ||
353 | ||
354 | ||
355 | ||
356 | ||
357 | ||
358 | ||
359 |