Clean-up
[u/mrichter/AliRoot.git] / EVGEN / AliGenEMlib.cxx
CommitLineData
e40b9538 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
35ClassImp(AliGenEMlib)
36
37//==========================================================================
38//
39// Definition of Particle Distributions
40//
41//==========================================================================
42
43//--------------------------------------------------------------------------
44//
45// Pizero
46//
47//--------------------------------------------------------------------------
48Int_t AliGenEMlib::IpPizero(TRandom *)
49{
50// Return pizero pdg code
51 return 111;
52}
53
54Double_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
71Double_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//--------------------------------------------------------------------------
82Int_t AliGenEMlib::IpEta(TRandom *)
83{
84// Return eta pdg code
85 return 221;
86}
87
88Double_t AliGenEMlib::PtEta( const Double_t *px, const Double_t */*dummy*/ )
89{
90// Eta pT
0db2f441 91 return MtScal(*px,1);
e40b9538 92}
93
94Double_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//--------------------------------------------------------------------------
105Int_t AliGenEMlib::IpRho(TRandom *)
106{
107// Return rho pdg code
108 return 113;
109}
110
111Double_t AliGenEMlib::PtRho( const Double_t *px, const Double_t */*dummy*/ )
112{
113// Rho pT
0db2f441 114 return MtScal(*px,2);
e40b9538 115}
116
117Double_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//--------------------------------------------------------------------------
128Int_t AliGenEMlib::IpOmega(TRandom *)
129{
130// Return omega pdg code
131 return 223;
132}
133
134Double_t AliGenEMlib::PtOmega( const Double_t *px, const Double_t */*dummy*/ )
135{
136// Omega pT
0db2f441 137 return MtScal(*px,3);
e40b9538 138}
139
140Double_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//--------------------------------------------------------------------------
151Int_t AliGenEMlib::IpEtaprime(TRandom *)
152{
153// Return etaprime pdg code
154 return 331;
155}
156
157Double_t AliGenEMlib::PtEtaprime( const Double_t *px, const Double_t */*dummy*/ )
158{
159// Eta pT
0db2f441 160 return MtScal(*px,4);
e40b9538 161}
162
163Double_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//--------------------------------------------------------------------------
174Int_t AliGenEMlib::IpPhi(TRandom *)
175{
176// Return phi pdg code
177 return 333;
178}
179
180Double_t AliGenEMlib::PtPhi( const Double_t *px, const Double_t */*dummy*/ )
181{
182// Phi pT
0db2f441 183 return MtScal(*px,5);
e40b9538 184}
185
186Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ )
187{
188 return YFlat(*py);
189
190}
191
e6165b4e 192Double_t AliGenEMlib::YFlat(Double_t /*y*/)
e40b9538 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
7892d33b 218// MASS 0=>PIZERO, 1=>ETA, 2=>RHO, 3=>OMEGA, 4=>ETAPRIME, 5=>PHI
e40b9538 219
220 const Double_t khm[6] = {0.13498, 0.54751, 0.7755, 0.78265, 0.95778, 1.01946};
e40b9538 221
222 Double_t scaledPt = sqrt(pt*pt + khm[np]*khm[np] - khm[0]*khm[0]);
223 Double_t scaledYield = PtPizero(&scaledPt, (Double_t*) 0);
224
225 // VALUE MESON/PI AT 5 GEV
226
227 Double_t normPt = 5.;
228 Double_t scaledNormPt = sqrt(normPt*normPt + khm[np]*khm[np] - khm[0]*khm[0]);
229 const Double_t kfmax[6]={1., 0.48, 1.0, 0.9, 0.25, 0.4};
230
231 Double_t norm = kfmax[np] * (PtPizero(&normPt, (Double_t*) 0) / PtPizero(&scaledNormPt, (Double_t*) 0));
232
233 return norm*(pt/scaledPt)*scaledYield;
234}
235
236//==========================================================================
237//
238// Set Getters
239//
240//==========================================================================
241
242typedef Double_t (*GenFunc) (const Double_t*, const Double_t*);
243
244typedef Int_t (*GenFuncIp) (TRandom *);
245
246GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const
247{
248// Return pointer to pT parameterisation
249 GenFunc func=0;
250 TString sname(tname);
251
252 switch (param)
253 {
254 case kPizero:
255 func=PtPizero;
256 break;
257 case kEta:
258 func=PtEta;
259 break;
260 case kRho:
261 func=PtRho;
262 break;
263 case kOmega:
264 func=PtOmega;
265 break;
266 case kEtaprime:
267 func=PtEtaprime;
268 break;
269 case kPhi:
270 func=PtPhi;
271 break;
272
273 default:
274 func=0;
275 printf("<AliGenEMlib::GetPt> unknown parametrisation\n");
276 }
277 return func;
278}
279
280GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const
281{
282// Return pointer to y- parameterisation
283 GenFunc func=0;
284 TString sname(tname);
285
286 switch (param)
287 {
288 case kPizero:
289 func=YPizero;
290 break;
291 case kEta:
292 func=YEta;
293 break;
294 case kRho:
295 func=YRho;
296 break;
297 case kOmega:
298 func=YOmega;
299 break;
300 case kEtaprime:
301 func=YEtaprime;
302 break;
303 case kPhi:
304 func=YPhi;
305 break;
306
307 default:
308 func=0;
309 printf("<AliGenEMlib::GetY> unknown parametrisation\n");
310 }
311 return func;
312}
313
314GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const
315{
316// Return pointer to particle type parameterisation
317 GenFuncIp func=0;
318 TString sname(tname);
319
320 switch (param)
321 {
322 case kPizero:
323 func=IpPizero;
324 break;
325 case kEta:
326 func=IpEta;
327 break;
328 case kRho:
329 func=IpRho;
330 break;
331 case kOmega:
332 func=IpOmega;
333 break;
334 case kEtaprime:
335 func=IpEtaprime;
336 break;
337 case kPhi:
338 func=IpPhi;
339 break;
340
341 default:
342 func=0;
343 printf("<AliGenEMlib::GetIp> unknown parametrisation\n");
344 }
345 return func;
346}
347
348
349
350
351
352
353
354
355
356
357
358