Update timestamps for new AMANDA simulation (17/02/2015)
[u/mrichter/AliRoot.git] / EVGEN / AliGenHMPIDlib.cxx
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 ClassImp(AliGenHMPIDlib)
37
38   //---------------------------------------
39   //    Pi Plus
40   //---------------------------------------
41 Int_t AliGenHMPIDlib::IpPiPlus(TRandom *)
42 {
43 //PDG code
44   return 211;     
45 }
46
47 Double_t AliGenHMPIDlib::PtPiPlusFlat( const Double_t *, const Double_t *)
48 {
49   //PiPlus FLAT pt-distribution
50   return 1; 
51 }
52
53 Double_t AliGenHMPIDlib::PtPiPlusExp( const Double_t *x, const Double_t *)
54 {
55   //PiPlus     EXP  pt-distribution
56   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  return 1;
63 }
64
65
66 //---------------------------------------
67 //        Pi Minus
68 //---------------------------------------
69 Int_t AliGenHMPIDlib::IpPiMinus(TRandom *)
70 {
71 //PDG code
72   return -211;     
73 }
74
75 Double_t AliGenHMPIDlib::PtPiMinusFlat( const Double_t *, const Double_t *)
76 {
77 // PiMinus FLAT pt-distribution
78   return 1; 
79 }
80
81 Double_t AliGenHMPIDlib::PtPiMinusExp( const Double_t *x, const Double_t *)
82 {
83 //PiMinus     EXP  pt-distribution
84   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   return 1;
91 }
92
93
94 //--------------------------------------------
95 //        K Plus
96 //--------------------------------------------
97 Int_t AliGenHMPIDlib::IpKPlus(TRandom *)
98 {
99 //PDG code
100   return 321;
101 }
102
103 Double_t AliGenHMPIDlib::PtKPlusFlat( const Double_t *, const Double_t *)
104 {
105 // K+ FLAT pt-distribution
106   return 1;
107 }
108
109 Double_t AliGenHMPIDlib::PtKPlusExp( const Double_t *x, const Double_t *)
110 {
111 // K+   EXP  pt-distribution
112   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   return 1;
119 }
120
121
122 //-----------------------------------------------
123 //         K Minus
124 //-----------------------------------------------
125 Int_t AliGenHMPIDlib::IpKMinus(TRandom *)
126 {
127 //PDG code
128   return -321;
129 }
130
131 Double_t AliGenHMPIDlib::PtKMinusFlat( const Double_t *, const Double_t *)
132 {
133 // K- FLAT pt-distribution
134   return 1;
135 }
136
137 Double_t AliGenHMPIDlib::PtKMinusExp( const Double_t *x, const Double_t *)
138 {
139 // K-   EXP  pt-distribution
140   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   return 1;
147 }
148
149
150 //-----------------------------------------------
151 //       K0 short
152 //-----------------------------------------------
153 Int_t AliGenHMPIDlib::IpK0s(TRandom *)
154 {
155 //PDG code
156   return 310;
157 }
158
159 Double_t AliGenHMPIDlib::PtK0sFlat( const Double_t *, const Double_t *)
160 {
161 // K0s FLAT pt-distribution
162   return 1;
163 }
164
165 Double_t AliGenHMPIDlib::PtK0sExp( const Double_t *x, const Double_t *)
166 {
167 // K0s   EXP  pt-distribution
168   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   return 1;
175 }
176
177
178 //---------------------------------------------
179 //         Phi(1020)
180 //---------------------------------------------
181 Int_t AliGenHMPIDlib::IpPhi(TRandom *)
182 {
183 //PDG code
184   return 333;     
185 }
186
187 Double_t AliGenHMPIDlib::PtPhiFlat( const Double_t *, const Double_t *)
188 {
189 // Phi FLAT pt-distribution
190   return 1; 
191 }
192
193 Double_t AliGenHMPIDlib::PtPhiExp( const Double_t *x, const Double_t *)
194 {
195 //phi     EXP  pt-distribution
196   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   return 1;
203 }
204
205
206 //-------------------------------------------------------
207 //                    PROTON
208 //-------------------------------------------------------
209 Int_t AliGenHMPIDlib::IpProton(TRandom *)
210 {
211 //PDG code
212   return 2122;     
213 }
214
215 Double_t AliGenHMPIDlib::PtProtonFlat( const Double_t *, const Double_t *)
216 {
217 // ProtonFLAT pt-distribution
218
219   return 1; 
220 }
221
222 Double_t AliGenHMPIDlib::PtProtonExp( const Double_t *x, const Double_t *)
223 {
224 //Proton    EXP  pt-distribution
225   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   return 1;
232 }
233
234
235 //-------------------------------------------------------
236 //                    PROTON-BAR
237 //-------------------------------------------------------
238 Int_t AliGenHMPIDlib::IpProtonBar(TRandom *)
239 {
240 //PDG code
241   return -2122;     
242 }
243
244 Double_t AliGenHMPIDlib::PtProtonBarFlat( const Double_t *, const Double_t *)
245 {
246 // ProtonBar FLAT pt-distribution
247
248   return 1; 
249 }
250
251 Double_t AliGenHMPIDlib::PtProtonBarExp( const Double_t *x, const Double_t *)
252 {
253 //ProtonBar     EXP  pt-distribution
254   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   return 1;
261 }
262
263
264 //-------------------------------------------------------
265 //                    LAMBDA
266 //-------------------------------------------------------
267 Int_t AliGenHMPIDlib::IpLambda(TRandom *)
268 {
269 //PDG code
270   return 3122;     
271 }
272
273 Double_t AliGenHMPIDlib::PtLambdaFlat( const Double_t *, const Double_t *)
274 {
275 // Lambda FLAT pt-distribution
276
277   return 1; 
278 }
279
280 Double_t AliGenHMPIDlib::PtLambdaExp( const Double_t *x, const Double_t *)
281 {
282 //Lambda     EXP  pt-distribution
283   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   return 1;
290 }
291
292
293 //-------------------------------------------------------
294 //                    LAMBDA-BAR
295 //-------------------------------------------------------
296 Int_t AliGenHMPIDlib::IpLambdaBar(TRandom *)
297 {
298 //PDG code
299   return -3122;     
300 }
301
302 Double_t AliGenHMPIDlib::PtLambdaBarFlat( const Double_t *, const Double_t *)
303 {
304 // LambdaBar FLAT pt-distribution
305
306   return 1; 
307 }
308
309 Double_t AliGenHMPIDlib::PtLambdaBarExp( const Double_t *x, const Double_t *)
310 {
311 //LambdaBar     EXP  pt-distribution
312   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   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   AliDebug(1,Form("PID: %i, form: %s",iPID,sForm));     
332    TString type(sForm);
333
334    switch(iPID) {
335
336    case kPiPlus:  
337       if     (type=="FLAT")                                         return PtPiPlusFlat;
338       else if(type=="EXP")                                          return PtPiPlusExp;
339       else {
340         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
341        }
342
343    case kPiMinus:  
344       if     (type=="FLAT")                                         return PtPiMinusFlat;
345       else if(type=="EXP")                                          return PtPiMinusExp;
346       else {
347         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
348        }
349
350   case kKPlus:
351       if     (type=="FLAT")                                         return PtKPlusFlat;
352       else if(type=="EXP")                                          return PtKPlusExp;
353       else {
354         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
355        }
356
357    case kKMinus:
358       if     (type=="FLAT")                                         return PtKMinusFlat;
359       else if(type=="EXP")                                          return PtKMinusExp;
360       else {
361         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
362        }
363
364
365   case kK0Short:  
366       if     (type=="FLAT")                                         return PtK0sFlat;
367       else if(type=="EXP")                                          return PtK0sExp;
368       else {
369         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
370        }
371
372
373    case kPhi:  
374       if     (type=="FLAT")                                         return PtPhiFlat;
375       else if(type=="EXP")                                          return PtPhiExp;
376       else {
377         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
378        }
379
380    case kProton:  
381       if     (type=="FLAT")                                         return PtProtonFlat;
382       else if(type=="EXP")                                          return PtProtonExp;
383       else {
384         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
385        }  
386
387    case kProtonBar:  
388       if     (type=="FLAT")                                         return PtProtonBarFlat;
389       else if(type=="EXP")                                          return PtProtonBarExp;
390       else {
391         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
392        }  
393
394    case kLambda0:  
395       if     (type=="FLAT")                                         return PtLambdaFlat;
396       else if(type=="EXP")                                          return PtLambdaExp;
397       else {
398         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
399        }  
400
401    case kLambda0Bar:  
402       if     (type=="FLAT")                                         return PtLambdaBarFlat;
403       else if(type=="EXP")                                          return PtLambdaBarExp;
404       else {
405         AliFatal(Form("Unknown Pt distribution form: %s",sForm));   return 0;
406        }  
407
408    default : AliFatal(Form("Unknown particle type: %i",iPID));      return 0;
409    }//switch
410 }
411
412 GenFunc AliGenHMPIDlib::GetY(Int_t iPID, const char *sForm) const
413 {
414   AliDebug(1,Form("PID: %i, form: %s",iPID,sForm));     
415
416    switch (iPID) {
417
418    case kPiPlus:                                                   return YPiPlusFlat;
419    case kPiMinus:                                                  return YPiMinusFlat;
420    case kKPlus:                                                    return YKPlusFlat;
421    case kKMinus:                                                   return YKMinusFlat;
422    case kK0Short:                                                  return YK0sFlat;
423    case kPhi:                                                      return YPhiFlat;
424    case kProton:                                                   return YProtonFlat;
425    case kProtonBar:                                                return YProtonBarFlat; 
426    case kLambda0:                                                  return YLambdaFlat;
427    case kLambda0Bar:                                               return YLambdaBarFlat;
428
429   default  : AliFatal(Form("Unknown particle type: %i",iPID));     return 0;
430
431    }//switch
432 }
433
434 GenFuncIp AliGenHMPIDlib::GetIp(Int_t iPID, const char *sForm) const
435 {
436 // Return pointer to particle type parameterisation
437   AliDebug(1,Form("PID: %i, form: %s",iPID,sForm));   //////////        
438
439   switch (iPID){
440
441     case kPiPlus:                                                return IpPiPlus;
442     case kPiMinus:                                               return IpPiMinus;
443     case kKPlus:                                                 return IpKPlus;
444     case kKMinus:                                                return IpKMinus;
445     case kK0Short:                                               return IpK0s;
446     case kPhi:                                                   return IpPhi;
447     case kProton:                                                return IpProton; 
448     case kProtonBar:                                             return IpProtonBar;
449     case kLambda0:                                               return IpLambda;
450     case kLambda0Bar:                                            return IpLambdaBar; 
451
452   default  : AliFatal(Form("Unknown particle type: %i",iPID));  return 0;
453   }
454 }
455