Line data Source code
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$ */
17 :
18 : // Library class for particle pt and y distributions used for
19 : // HMPID simulations.
20 : // To be used with AliGenParam.
21 : // The following particle typed can be simulated:
22 : // phi, lambda, k
23 : //
24 : // Author: Annalisa Mastroserio <Annalisa.Mastroserio@ba.infn.it>
25 : //
26 : //
27 :
28 : #include <TPDGCode.h>
29 : #include <TMath.h>
30 : #include <TRandom.h>
31 : #include <TString.h>
32 :
33 : #include "AliGenHMPIDlib.h"
34 : #include "AliLog.h"
35 :
36 6 : ClassImp(AliGenHMPIDlib)
37 :
38 : //---------------------------------------
39 : // Pi Plus
40 : //---------------------------------------
41 : Int_t AliGenHMPIDlib::IpPiPlus(TRandom *)
42 : {
43 : //PDG code
44 0 : return 211;
45 : }
46 :
47 : Double_t AliGenHMPIDlib::PtPiPlusFlat( const Double_t *, const Double_t *)
48 : {
49 : //PiPlus FLAT pt-distribution
50 0 : return 1;
51 : }
52 :
53 : Double_t AliGenHMPIDlib::PtPiPlusExp( const Double_t *x, const Double_t *)
54 : {
55 : //PiPlus EXP pt-distribution
56 0 : return x[0]*TMath::Exp(-x[0]/0.17);
57 : }
58 :
59 : Double_t AliGenHMPIDlib::YPiPlusFlat(const Double_t *,const Double_t *)
60 : {
61 : //PiPlus y-distribution
62 0 : return 1;
63 : }
64 :
65 :
66 : //---------------------------------------
67 : // Pi Minus
68 : //---------------------------------------
69 : Int_t AliGenHMPIDlib::IpPiMinus(TRandom *)
70 : {
71 : //PDG code
72 0 : return -211;
73 : }
74 :
75 : Double_t AliGenHMPIDlib::PtPiMinusFlat( const Double_t *, const Double_t *)
76 : {
77 : // PiMinus FLAT pt-distribution
78 0 : return 1;
79 : }
80 :
81 : Double_t AliGenHMPIDlib::PtPiMinusExp( const Double_t *x, const Double_t *)
82 : {
83 : //PiMinus EXP pt-distribution
84 0 : return x[0]*TMath::Exp(-x[0]/0.17);
85 : }
86 :
87 : Double_t AliGenHMPIDlib::YPiMinusFlat(const Double_t *,const Double_t *)
88 : {
89 : //PiMinus y-distribution
90 0 : return 1;
91 : }
92 :
93 :
94 : //--------------------------------------------
95 : // K Plus
96 : //--------------------------------------------
97 : Int_t AliGenHMPIDlib::IpKPlus(TRandom *)
98 : {
99 : //PDG code
100 0 : return 321;
101 : }
102 :
103 : Double_t AliGenHMPIDlib::PtKPlusFlat( const Double_t *, const Double_t *)
104 : {
105 : // K+ FLAT pt-distribution
106 0 : return 1;
107 : }
108 :
109 : Double_t AliGenHMPIDlib::PtKPlusExp( const Double_t *x, const Double_t *)
110 : {
111 : // K+ EXP pt-distribution
112 0 : return x[0]*TMath::Exp(-x[0]/0.17);
113 : }
114 :
115 : Double_t AliGenHMPIDlib::YKPlusFlat(const Double_t *,const Double_t *)
116 : {
117 : // K+ y-distribution
118 0 : return 1;
119 : }
120 :
121 :
122 : //-----------------------------------------------
123 : // K Minus
124 : //-----------------------------------------------
125 : Int_t AliGenHMPIDlib::IpKMinus(TRandom *)
126 : {
127 : //PDG code
128 0 : return -321;
129 : }
130 :
131 : Double_t AliGenHMPIDlib::PtKMinusFlat( const Double_t *, const Double_t *)
132 : {
133 : // K- FLAT pt-distribution
134 0 : return 1;
135 : }
136 :
137 : Double_t AliGenHMPIDlib::PtKMinusExp( const Double_t *x, const Double_t *)
138 : {
139 : // K- EXP pt-distribution
140 0 : return x[0]*TMath::Exp(-x[0]/0.17);
141 : }
142 :
143 : Double_t AliGenHMPIDlib::YKMinusFlat(const Double_t *,const Double_t *)
144 : {
145 : // K- y-distribution
146 0 : return 1;
147 : }
148 :
149 :
150 : //-----------------------------------------------
151 : // K0 short
152 : //-----------------------------------------------
153 : Int_t AliGenHMPIDlib::IpK0s(TRandom *)
154 : {
155 : //PDG code
156 0 : return 310;
157 : }
158 :
159 : Double_t AliGenHMPIDlib::PtK0sFlat( const Double_t *, const Double_t *)
160 : {
161 : // K0s FLAT pt-distribution
162 0 : return 1;
163 : }
164 :
165 : Double_t AliGenHMPIDlib::PtK0sExp( const Double_t *x, const Double_t *)
166 : {
167 : // K0s EXP pt-distribution
168 0 : return x[0]*TMath::Exp(-x[0]/0.17);
169 : }
170 :
171 : Double_t AliGenHMPIDlib::YK0sFlat(const Double_t *,const Double_t *)
172 : {
173 : // K0s y-distribution
174 0 : return 1;
175 : }
176 :
177 :
178 : //---------------------------------------------
179 : // Phi(1020)
180 : //---------------------------------------------
181 : Int_t AliGenHMPIDlib::IpPhi(TRandom *)
182 : {
183 : //PDG code
184 0 : return 333;
185 : }
186 :
187 : Double_t AliGenHMPIDlib::PtPhiFlat( const Double_t *, const Double_t *)
188 : {
189 : // Phi FLAT pt-distribution
190 0 : return 1;
191 : }
192 :
193 : Double_t AliGenHMPIDlib::PtPhiExp( const Double_t *x, const Double_t *)
194 : {
195 : //phi EXP pt-distribution
196 0 : return x[0]*TMath::Exp(-x[0]/0.17);
197 : }
198 :
199 : Double_t AliGenHMPIDlib::YPhiFlat(const Double_t *,const Double_t *)
200 : {
201 : //phi y-distribution
202 0 : return 1;
203 : }
204 :
205 :
206 : //-------------------------------------------------------
207 : // PROTON
208 : //-------------------------------------------------------
209 : Int_t AliGenHMPIDlib::IpProton(TRandom *)
210 : {
211 : //PDG code
212 0 : return 2122;
213 : }
214 :
215 : Double_t AliGenHMPIDlib::PtProtonFlat( const Double_t *, const Double_t *)
216 : {
217 : // ProtonFLAT pt-distribution
218 :
219 0 : return 1;
220 : }
221 :
222 : Double_t AliGenHMPIDlib::PtProtonExp( const Double_t *x, const Double_t *)
223 : {
224 : //Proton EXP pt-distribution
225 0 : return x[0]*TMath::Exp(-x[0]/0.17);
226 : }
227 :
228 : Double_t AliGenHMPIDlib::YProtonFlat(const Double_t *,const Double_t *)
229 : {
230 : //Proton y-distribution
231 0 : return 1;
232 : }
233 :
234 :
235 : //-------------------------------------------------------
236 : // PROTON-BAR
237 : //-------------------------------------------------------
238 : Int_t AliGenHMPIDlib::IpProtonBar(TRandom *)
239 : {
240 : //PDG code
241 0 : return -2122;
242 : }
243 :
244 : Double_t AliGenHMPIDlib::PtProtonBarFlat( const Double_t *, const Double_t *)
245 : {
246 : // ProtonBar FLAT pt-distribution
247 :
248 0 : return 1;
249 : }
250 :
251 : Double_t AliGenHMPIDlib::PtProtonBarExp( const Double_t *x, const Double_t *)
252 : {
253 : //ProtonBar EXP pt-distribution
254 0 : return x[0]*TMath::Exp(-x[0]/0.17);
255 : }
256 :
257 : Double_t AliGenHMPIDlib::YProtonBarFlat(const Double_t *,const Double_t *)
258 : {
259 : //ProtonBar y-distribution
260 0 : return 1;
261 : }
262 :
263 :
264 : //-------------------------------------------------------
265 : // LAMBDA
266 : //-------------------------------------------------------
267 : Int_t AliGenHMPIDlib::IpLambda(TRandom *)
268 : {
269 : //PDG code
270 0 : return 3122;
271 : }
272 :
273 : Double_t AliGenHMPIDlib::PtLambdaFlat( const Double_t *, const Double_t *)
274 : {
275 : // Lambda FLAT pt-distribution
276 :
277 0 : return 1;
278 : }
279 :
280 : Double_t AliGenHMPIDlib::PtLambdaExp( const Double_t *x, const Double_t *)
281 : {
282 : //Lambda EXP pt-distribution
283 0 : return x[0]*TMath::Exp(-x[0]/0.17);
284 : }
285 :
286 : Double_t AliGenHMPIDlib::YLambdaFlat(const Double_t *,const Double_t *)
287 : {
288 : //Lambda y-distribution
289 0 : return 1;
290 : }
291 :
292 :
293 : //-------------------------------------------------------
294 : // LAMBDA-BAR
295 : //-------------------------------------------------------
296 : Int_t AliGenHMPIDlib::IpLambdaBar(TRandom *)
297 : {
298 : //PDG code
299 0 : return -3122;
300 : }
301 :
302 : Double_t AliGenHMPIDlib::PtLambdaBarFlat( const Double_t *, const Double_t *)
303 : {
304 : // LambdaBar FLAT pt-distribution
305 :
306 0 : return 1;
307 : }
308 :
309 : Double_t AliGenHMPIDlib::PtLambdaBarExp( const Double_t *x, const Double_t *)
310 : {
311 : //LambdaBar EXP pt-distribution
312 0 : return x[0]*TMath::Exp(-x[0]/0.17);
313 : }
314 :
315 : Double_t AliGenHMPIDlib::YLambdaBarFlat(const Double_t *,const Double_t *)
316 : {
317 : //LambdaBar y-distribution
318 0 : return 1;
319 : }
320 :
321 :
322 :
323 :
324 :
325 : typedef Double_t (*GenFunc) (const Double_t*, const Double_t*);
326 : typedef Int_t (*GenFuncIp) (TRandom *);
327 :
328 : GenFunc AliGenHMPIDlib::GetPt(Int_t iPID, const char * sForm) const
329 : {
330 : // Return pointer to Pt parameterisation
331 0 : AliDebug(1,Form("PID: %i, form: %s",iPID,sForm));
332 0 : TString type(sForm);
333 :
334 0 : switch(iPID) {
335 :
336 : case kPiPlus:
337 0 : if (type=="FLAT") return PtPiPlusFlat;
338 0 : else if(type=="EXP") return PtPiPlusExp;
339 : else {
340 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
341 : }
342 :
343 : case kPiMinus:
344 0 : if (type=="FLAT") return PtPiMinusFlat;
345 0 : else if(type=="EXP") return PtPiMinusExp;
346 : else {
347 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
348 : }
349 :
350 : case kKPlus:
351 0 : if (type=="FLAT") return PtKPlusFlat;
352 0 : else if(type=="EXP") return PtKPlusExp;
353 : else {
354 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
355 : }
356 :
357 : case kKMinus:
358 0 : if (type=="FLAT") return PtKMinusFlat;
359 0 : else if(type=="EXP") return PtKMinusExp;
360 : else {
361 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
362 : }
363 :
364 :
365 : case kK0Short:
366 0 : if (type=="FLAT") return PtK0sFlat;
367 0 : else if(type=="EXP") return PtK0sExp;
368 : else {
369 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
370 : }
371 :
372 :
373 : case kPhi:
374 0 : if (type=="FLAT") return PtPhiFlat;
375 0 : else if(type=="EXP") return PtPhiExp;
376 : else {
377 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
378 : }
379 :
380 : case kProton:
381 0 : if (type=="FLAT") return PtProtonFlat;
382 0 : else if(type=="EXP") return PtProtonExp;
383 : else {
384 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
385 : }
386 :
387 : case kProtonBar:
388 0 : if (type=="FLAT") return PtProtonBarFlat;
389 0 : else if(type=="EXP") return PtProtonBarExp;
390 : else {
391 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
392 : }
393 :
394 : case kLambda0:
395 0 : if (type=="FLAT") return PtLambdaFlat;
396 0 : else if(type=="EXP") return PtLambdaExp;
397 : else {
398 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
399 : }
400 :
401 : case kLambda0Bar:
402 0 : if (type=="FLAT") return PtLambdaBarFlat;
403 0 : else if(type=="EXP") return PtLambdaBarExp;
404 : else {
405 0 : AliFatal(Form("Unknown Pt distribution form: %s",sForm)); return 0;
406 : }
407 :
408 0 : default : AliFatal(Form("Unknown particle type: %i",iPID)); return 0;
409 : }//switch
410 0 : }
411 :
412 : GenFunc AliGenHMPIDlib::GetY(Int_t iPID, const char *sForm) const
413 : {
414 0 : AliDebug(1,Form("PID: %i, form: %s",iPID,sForm));
415 :
416 0 : switch (iPID) {
417 :
418 0 : case kPiPlus: return YPiPlusFlat;
419 0 : case kPiMinus: return YPiMinusFlat;
420 0 : case kKPlus: return YKPlusFlat;
421 0 : case kKMinus: return YKMinusFlat;
422 0 : case kK0Short: return YK0sFlat;
423 0 : case kPhi: return YPhiFlat;
424 0 : case kProton: return YProtonFlat;
425 0 : case kProtonBar: return YProtonBarFlat;
426 0 : case kLambda0: return YLambdaFlat;
427 0 : case kLambda0Bar: return YLambdaBarFlat;
428 :
429 0 : default : AliFatal(Form("Unknown particle type: %i",iPID)); return 0;
430 :
431 : }//switch
432 0 : }
433 :
434 : GenFuncIp AliGenHMPIDlib::GetIp(Int_t iPID, const char *sForm) const
435 : {
436 : // Return pointer to particle type parameterisation
437 0 : AliDebug(1,Form("PID: %i, form: %s",iPID,sForm)); //////////
438 :
439 0 : switch (iPID){
440 :
441 0 : case kPiPlus: return IpPiPlus;
442 0 : case kPiMinus: return IpPiMinus;
443 0 : case kKPlus: return IpKPlus;
444 0 : case kKMinus: return IpKMinus;
445 0 : case kK0Short: return IpK0s;
446 0 : case kPhi: return IpPhi;
447 0 : case kProton: return IpProton;
448 0 : case kProtonBar: return IpProtonBar;
449 0 : case kLambda0: return IpLambda;
450 0 : case kLambda0Bar: return IpLambdaBar;
451 :
452 0 : default : AliFatal(Form("Unknown particle type: %i",iPID)); return 0;
453 : }
454 0 : }
455 :
|
