* EVGEN/AliGenEMCocktail.cxx (& .h) is the class that generates the cocktail follow...
[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
91 return MtScal(*px,2);
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
114 return MtScal(*px,3);
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
137 return MtScal(*px,4);
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
160 return MtScal(*px,5);
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
183 return MtScal(*px,6);
184}
185
186Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ )
187{
188 return YFlat(*py);
189
190}
191
192Double_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
243typedef Double_t (*GenFunc) (const Double_t*, const Double_t*);
244
245typedef Int_t (*GenFuncIp) (TRandom *);
246
247GenFunc 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
281GenFunc 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
315GenFuncIp 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