Missing initialization added (Alpha)
[u/mrichter/AliRoot.git] / EVGEN / AliGenGSIlib.cxx
CommitLineData
014616eb 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 **************************************************************************/
fdcaa191 15
014616eb 16/*
17$Log$
b9d0a01d 18Revision 1.5.10.1 2002/06/10 14:57:41 hristov
19Merged with v3-08-02
20
21Revision 1.6 2002/04/16 15:53:19 morsch
22Coding rule violations corrected.
23
f4cd22aa 24Revision 1.5 2001/05/15 15:43:23 morsch
25Update of library for low mass resonances (Yiota Foka)
26
fdcaa191 27Revision 1.4 2001/03/09 13:01:41 morsch
28- enum constants for paramterisation type (particle family) moved to AliGen*lib.h
29- use AliGenGSIlib::kUpsilon, AliGenPHOSlib::kEtaPrime to access the constants
30
34f60c01 31Revision 1.3 2000/12/21 16:24:06 morsch
32Coding convention clean-up
33
675e9664 34Revision 1.2 2000/11/30 07:12:50 alibrary
35Introducing new Rndm and QA classes
36
65fb704d 37Revision 1.1 2000/06/15 08:48:43 morsch
38AliGenGSIlib with parametersations for GSI physics simulation added (YF, MI)
39
014616eb 40Revision 1.7 2000/05/02 08:12:13 morsch
41Coding rule violations corrected.
42
43Revision 1.6 1999/09/29 09:24:14 fca
44Introduction of the Copyright and cvs Log
45
46*/
47
fdcaa191 48/////////////////////////////////////////////////////////////////////////////
49// //
50// Implementation of AliGenlib to collect parametrisations used for //
51// GSI simulations. //
52// It is an extension of AliMUONLib providing in addition the option //
53// for different parametrisations of pt, y and ip for every particle type //
54// //
55// Responsible: Andres.Sandoval@cern.ch //
56// //
57/////////////////////////////////////////////////////////////////////////////
675e9664 58
65fb704d 59#include "TMath.h"
fdcaa191 60#include "TRandom.h"
65fb704d 61#include "TString.h"
014616eb 62#include "AliGenGSIlib.h"
014616eb 63
fdcaa191 64
014616eb 65ClassImp(AliGenGSIlib)
66
fdcaa191 67//==========================================================================
014616eb 68//
fdcaa191 69// Definition of Particle Distributions
70//
71//==========================================================================
014616eb 72//
fdcaa191 73// Upsilon
74//
75//--------------------------------------------------------------------------
76//
77// upsilon particle composition
78//
79//--------------------------------------------------------------------------
80Int_t AliGenGSIlib::IpUpsilon(TRandom *)
014616eb 81{
f4cd22aa 82// Return upsilon pdg code
fdcaa191 83
84 return 553;
85
86}
f4cd22aa 87Double_t AliGenGSIlib::PtUpsilonFlat( Double_t *px, Double_t *dummy )
88{
fdcaa191 89//--------------------------------------------------------------------------
90//
91// upsilon pt-distribution FLAT
92//
93//____________________________________________________________--------------
f4cd22aa 94
fdcaa191 95 const Double_t kptmin = 0.0;
96 const Double_t kptmax = 15.0;
014616eb 97 Double_t x=*px;
fdcaa191 98 Double_t weight = 0.;
99
100 if (kptmin < x < kptmax) weight = 1.;
101
102 return weight;
103
104}
f4cd22aa 105Double_t AliGenGSIlib::YUpsilonFlat(Double_t *py, Double_t *dummy)
106{
fdcaa191 107//--------------------------------------------------------------------------
108//
109// upsilon y-distribution FLAT
110//
111//--------------------------------------------------------------------------
fdcaa191 112
113 const Double_t ky0 = 1.5;
114 const Double_t kb=1.;
115 Double_t yu;
116 Double_t y=TMath::Abs(*py);
117
118 if (y < ky0)
119 yu=kb;
120 else
121 yu = 0.;
122
123 return yu;
124
125}
f4cd22aa 126Double_t AliGenGSIlib::PtUpsilonRitman( Double_t *px, Double_t *dummy )
127{
fdcaa191 128//--------------------------------------------------------------------------
129//
130// upsilon pt-distribution RITMAN
131//
132//--------------------------------------------------------------------------
fdcaa191 133
014616eb 134 const Double_t kpt0 = 4.7;
135 const Double_t kxn = 3.5;
136 Double_t x=*px;
fdcaa191 137
014616eb 138 Double_t pass1 = 1.+((x*x)/(kpt0*kpt0));
fdcaa191 139
014616eb 140 return x/TMath::Power(pass1,kxn);
141
142}
f4cd22aa 143Double_t AliGenGSIlib::YUpsilonRitman(Double_t *py, Double_t *dummy)
144{
fdcaa191 145//--------------------------------------------------------------------------
014616eb 146//
fdcaa191 147// upsilon y-distribution RITMAN
014616eb 148//
fdcaa191 149//--------------------------------------------------------------------------
014616eb 150
fdcaa191 151 const Double_t ky0 = 3.;
152 const Double_t kb=1.;
153 Double_t yu;
154 Double_t y=TMath::Abs(*py);
014616eb 155
fdcaa191 156 if (y < ky0)
014616eb 157 yu=kb;
fdcaa191 158 else
014616eb 159 yu=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
fdcaa191 160
161 return yu;
162
014616eb 163}
f4cd22aa 164Double_t AliGenGSIlib::PtUpsilonKarel( Double_t *px, Double_t *dummy )
165{
fdcaa191 166//--------------------------------------------------------------------------
014616eb 167//
fdcaa191 168// upsilon pt-distribution kAREL
169//
170//--------------------------------------------------------------------------
f4cd22aa 171// to implement
014616eb 172
fdcaa191 173 return 0.1;
174
014616eb 175}
f4cd22aa 176Double_t AliGenGSIlib::YUpsilonKarel(Double_t *py, Double_t *dummy)
177{
fdcaa191 178//--------------------------------------------------------------------------
014616eb 179//
fdcaa191 180// upsilon y-distribution KAREL
014616eb 181//
fdcaa191 182//--------------------------------------------------------------------------
014616eb 183
014616eb 184 //to implement
014616eb 185
fdcaa191 186 return 0.2;
014616eb 187
fdcaa191 188}
f4cd22aa 189Double_t AliGenGSIlib::PtUpsilonMUON( Double_t *px, Double_t *dummy )
190{
fdcaa191 191//--------------------------------------------------------------------------
192//
193// upsilon pt-distribution MUONlib
194//
195//--------------------------------------------------------------------------
fdcaa191 196
014616eb 197 const Double_t kpt0 = 5.3;
198 const Double_t kxn = 2.5;
199 Double_t x=*px;
fdcaa191 200
014616eb 201 Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
fdcaa191 202
014616eb 203 return x/TMath::Power(pass1,kxn);
fdcaa191 204
014616eb 205}
f4cd22aa 206Double_t AliGenGSIlib::YUpsilonMUON(Double_t *py, Double_t *dummy)
207{
fdcaa191 208//--------------------------------------------------------------------------
014616eb 209//
fdcaa191 210// upsilon y-distribution MUONlib
014616eb 211//
fdcaa191 212//--------------------------------------------------------------------------
fdcaa191 213
014616eb 214 const Double_t ky0 = 3.;
215 const Double_t kb=1.;
216 Double_t yu;
217 Double_t y=TMath::Abs(*py);
fdcaa191 218
014616eb 219 if (y < ky0)
220 yu=kb;
221 else
222 yu=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
fdcaa191 223
014616eb 224 return yu;
fdcaa191 225
014616eb 226}
fdcaa191 227//--------------------------------------------------------------------------
228//
229// J/Psi
230//
f4cd22aa 231Int_t AliGenGSIlib::IpJpsi(TRandom *)
232{
fdcaa191 233//--------------------------------------------------------------------------
234//
235// J/Psi particle composition
014616eb 236//
fdcaa191 237//--------------------------------------------------------------------------
fdcaa191 238
239 return 443;
240
014616eb 241}
f4cd22aa 242Double_t AliGenGSIlib::PtJpsiFlat( Double_t *px, Double_t *dummy )
243{
fdcaa191 244//--------------------------------------------------------------------------
245//
246// J/Psi pt-distribution FLAT
247//
248//--------------------------------------------------------------------------
014616eb 249
fdcaa191 250 const Double_t kptmin = 0.0;
251 const Double_t kptmax = 15.0;
252 Double_t x=*px;
253 Double_t weight = 0.;
014616eb 254
fdcaa191 255 if (kptmin < x < kptmax) weight = 1.;
014616eb 256
fdcaa191 257 return weight;
258
259}
f4cd22aa 260Double_t AliGenGSIlib::YJpsiFlat(Double_t *py, Double_t *dummy)
261{
fdcaa191 262//--------------------------------------------------------------------------
263//
264// J/Psi y-distribution FLAT
265//
266//--------------------------------------------------------------------------
fdcaa191 267
268 const Double_t ky0 = 1.5;
269 const Double_t kb=1.;
270 Double_t yu;
271 Double_t y=TMath::Abs(*py);
272
273 if (y < ky0)
274 yu=kb;
275 else
276 yu = 0.;
277
278 return yu;
279
280}
f4cd22aa 281Double_t AliGenGSIlib::PtJpsiMUON( Double_t *px, Double_t *dummy )
282{
fdcaa191 283//--------------------------------------------------------------------------
284//
285// J/Psi pt-distribution MUONlib
286//
287//--------------------------------------------------------------------------
fdcaa191 288
289 const Double_t kpt0 = 4.;
290 const Double_t kxn = 3.6;
291 Double_t x=*px;
292
293 Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
294 return x/TMath::Power(pass1,kxn);
295
296}
f4cd22aa 297Double_t AliGenGSIlib::PtJpsiRitman( Double_t *px, Double_t *dummy )
298{
fdcaa191 299//--------------------------------------------------------------------------
300//
301// J/Psi pt-distribution Ritman
302//
303//--------------------------------------------------------------------------
fdcaa191 304
305 const Double_t kpt0 = 2.3;
306 const Double_t kxn = 3.5;
307 Double_t x=*px;
308
309 Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
310
311 return x/TMath::Power(pass1,kxn);
312
313}
f4cd22aa 314Double_t AliGenGSIlib::YJpsiMUON(Double_t *py, Double_t *dummy)
315{
fdcaa191 316//--------------------------------------------------------------------------
317//
318// J/Psi y-distribution MUONlib
319//
320//--------------------------------------------------------------------------
fdcaa191 321
322 const Double_t ky0 = 4.;
323 const Double_t kb=1.;
324 Double_t yj;
325 Double_t y=TMath::Abs(*py);
326
327 if (y < ky0)
328 yj=kb;
329 else
330 yj=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
331 return yj;
332
333}
334//--------------------------------------------------------------------------
335//
336// J/Psi pt-distribution by Sergei
337//
338//--------------------------------------------------------------------------
339//Double_t AliGenGSIlib::PtJpsi( Double_t *px, Double_t *dummy )
340//{
341
342// return x = gRandom->Rndm()*10.;
343
344//}
345//--------------------------------------------------------------------------
346//
347// J/Psi y-distribution by Sergei
348//
349//--------------------------------------------------------------------------
350/*Double_t AliGenGSIlib::YJpsi(Double_t *py, Double_t *dummy)
351{
352
353 const Double_t ky0 = 4.;
354 const Double_t kb=1.;
355 Double_t yj;
356 Double_t y=TMath::Abs(*py);
357 //
358 if (y < ky0)
359 yj=kb;
360 else
361 yj=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
362 return yj;
363
364}
365*/
366//--------------------------------------------------------------------------
367//
368// Charm
369//
370//--------------------------------------------------------------------------
f4cd22aa 371Int_t AliGenGSIlib::IpCharm(TRandom *ran)
372{
fdcaa191 373//
374// charm particle composition
375//
376//--------------------------------------------------------------------------
fdcaa191 377
378 Float_t random;
379 Int_t ip;
380 // 411,421,431,4122
381 random = ran->Rndm();
382 if (random < 0.5) {
383 ip=411;
384 } else if (random < 0.75) {
385 ip=421;
386 } else if (random < 0.90) {
387 ip=431;
388 } else {
389 ip=4122;
390 }
391 if (ran->Rndm() < 0.5) {ip=-ip;}
392
393 return ip;
394
395}
f4cd22aa 396Double_t AliGenGSIlib::PtCharmFlat( Double_t *px, Double_t *dummy)
397{
fdcaa191 398//--------------------------------------------------------------------------
399//
400// charm pt-distribution, FLAT
401//
402//--------------------------------------------------------------------------
fdcaa191 403
404 Double_t x=*px;
405
406 if (x>10.) x = 0.;
407 else x=1.;
408 return x ;
409
410}
f4cd22aa 411Double_t AliGenGSIlib::PtCharmGSI( Double_t *px, Double_t *dummy)
412{
fdcaa191 413//--------------------------------------------------------------------------
414//
415// charm pt-distribution, from Dariuzs Miskowiec
416//
417//--------------------------------------------------------------------------
f4cd22aa 418
fdcaa191 419 //Taken from PYTHIA with MRS D-' (3031 from PDFLIB), K=3.0
420 const Double_t kp1 = 1.3;
421 const Double_t kp2 = 0.39;
422 const Double_t kp3 = 0.018;
423 const Double_t kp4 = 0.91;
424 Double_t x=*px;
425
426 Double_t pass1 =TMath::Exp(-x/kp2) ;
427 Double_t pass2 =TMath::Exp(-x/kp4) ;
428 return TMath::Power(x,kp1) * (pass1 + kp3 * pass2);
429
430}
f4cd22aa 431Double_t AliGenGSIlib::PtCharmMUON( Double_t *px, Double_t *dummy)
432{
fdcaa191 433//--------------------------------------------------------------------------
434//
435// charm pt-distribution, from MUONlib
436//
437//--------------------------------------------------------------------------
fdcaa191 438
439 const Double_t kpt0 = 4.08;
440 const Double_t kxn = 9.40;
441 Double_t x=*px;
442
443 Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
444
445 return x/TMath::Power(pass1,kxn);
446
447}
f4cd22aa 448Double_t AliGenGSIlib::YCharm( Double_t *px, Double_t *dummy)
449{
fdcaa191 450//--------------------------------------------------------------------------
451//
452// charm y-distribution
453//
454//--------------------------------------------------------------------------
fdcaa191 455
456 Double_t *dum=0;
457
458 return YJpsiMUON(px,dum);
459
460}
461//--------------------------------------------------------------------------
462//
463// Beauty
464//
465//--------------------------------------------------------------------------
f4cd22aa 466Int_t AliGenGSIlib::IpBeauty(TRandom *ran)
467{
fdcaa191 468//
469// beauty particle composition
470//
471//--------------------------------------------------------------------------
fdcaa191 472
473 Float_t random;
474 Int_t ip;
475 random = ran->Rndm();
476 if (random < 0.5) {
477 ip=511;
478 } else if (random < 0.75) {
479 ip=521;
480 } else if (random < 0.90) {
481 ip=531;
482 } else {
483 ip=5122;
484 }
485 if (ran->Rndm() < 0.5) {ip=-ip;}
486
487 return ip;
488}
f4cd22aa 489Double_t AliGenGSIlib::PtBeautyFlat( Double_t *px, Double_t *dummy)
490{
fdcaa191 491//--------------------------------------------------------------------------
492//
493// beauty pt-distribution, FLAT
494//
495//--------------------------------------------------------------------------
fdcaa191 496
497 Double_t x=*px;
498
499 if (x>10.) x=0.;
500 else x = 1.;
501 return x ;
502
503}
f4cd22aa 504Double_t AliGenGSIlib::PtBeautyGSI( Double_t *px, Double_t *dummy)
505{
fdcaa191 506//--------------------------------------------------------------------------
507//
508//
509// beauty pt-distribution, from D. Miskowiec
510//
511//--------------------------------------------------------------------------
f4cd22aa 512
fdcaa191 513 //Taken from PYTHIA with MRS D-' (3031 from PDFLIB), K=3.0
514 const Double_t kp1 = 1.3;
515 const Double_t kp2 = 1.78;
516 const Double_t kp3 = 0.0096;
517 const Double_t kp4 = 4.16;
518 Double_t x=*px;
519
520 Double_t pass1 =TMath::Exp(-x/kp2) ;
521 Double_t pass2 =TMath::Exp(-x/kp4) ;
522
523 return TMath::Power(x,kp1) * (pass1 + kp3 * pass2);
524
525}
f4cd22aa 526Double_t AliGenGSIlib::PtBeautyMUON( Double_t *px, Double_t *dummy)
527{
fdcaa191 528//--------------------------------------------------------------------------
529//
530// beauty pt-distribution, from MUONlib
531//
532//--------------------------------------------------------------------------
fdcaa191 533
534 const Double_t kpt0 = 4.;
535 const Double_t kxn = 3.6;
536 Double_t x=*px;
537
538 Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
539
540 return x/TMath::Power(pass1,kxn);
541
542}
f4cd22aa 543Double_t AliGenGSIlib::YBeauty( Double_t *px, Double_t *dummy)
544{
fdcaa191 545//--------------------------------------------------------------------------
546//
547// beauty y-distribution
548//
549//--------------------------------------------------------------------------
fdcaa191 550
551 Double_t *dum=0;
552
553 return YJpsiMUON(px,dum);
554
555}
556//--------------------------------------------------------------------------
557//
558// Eta
559//
560//--------------------------------------------------------------------------
f4cd22aa 561Int_t AliGenGSIlib::IpEta(TRandom *)
562{
fdcaa191 563//
564// eta particle composition
565//
566//--------------------------------------------------------------------------
fdcaa191 567
568 return 221;
569
570}
f4cd22aa 571Double_t AliGenGSIlib::PtEtaPHOS( Double_t *px, Double_t *dummy )
572{
fdcaa191 573//--------------------------------------------------------------------------
574//
575// eta pt-distribution
576//
577//____________________________________________________________--------------
fdcaa191 578
579 return PtScal(*px,3); // 3==> Eta in the PtScal function
580
581}
f4cd22aa 582Double_t AliGenGSIlib::YEtaPHOS(Double_t *py, Double_t *dummy)
583{
fdcaa191 584//--------------------------------------------------------------------------
585//
586// eta y-distribution
587//
588//--------------------------------------------------------------------------
fdcaa191 589
590 const Double_t ka = 1000.;
591 const Double_t kdy = 4.;
592
593 Double_t y=TMath::Abs(*py);
594
595 Double_t ex = y*y/(2*kdy*kdy);
596
597 return ka*TMath::Exp(-ex);
598
599}
600//--------------------------------------------------------------------------
601//
602// Etaprime
603//
604//--------------------------------------------------------------------------
f4cd22aa 605Int_t AliGenGSIlib::IpEtaprime(TRandom *)
606{
fdcaa191 607//
608// etaprime particle composition
609//
610//--------------------------------------------------------------------------
fdcaa191 611
612 return 331;
613
614}
f4cd22aa 615Double_t AliGenGSIlib::PtEtaprimePHOS( Double_t *px, Double_t *dummy )
616{
fdcaa191 617//--------------------------------------------------------------------------
618//
619// etaprime pt-distribution
620//
621//____________________________________________________________--------------
fdcaa191 622
623 return PtScal(*px,5); // 5==> Etaprime in the PtScal function
624
625}
f4cd22aa 626Double_t AliGenGSIlib::YEtaprimePHOS(Double_t *py, Double_t *dummy)
627{
fdcaa191 628//--------------------------------------------------------------------------
629//
630// etaprime y-distribution
631//
632//--------------------------------------------------------------------------
014616eb 633
fdcaa191 634 const Double_t ka = 1000.;
635 const Double_t kdy = 4.;
014616eb 636
fdcaa191 637 Double_t y=TMath::Abs(*py);
638
639 Double_t ex = y*y/(2*kdy*kdy);
640
641 return ka*TMath::Exp(-ex);
642
643}
644//--------------------------------------------------------------------------
645//
646// omega
647//
648//--------------------------------------------------------------------------
f4cd22aa 649Int_t AliGenGSIlib::IpOmega(TRandom *)
650{
fdcaa191 651//
652// omega particle composition
653//
654//--------------------------------------------------------------------------
fdcaa191 655
656 return 223;
657
658}
f4cd22aa 659Double_t AliGenGSIlib::PtOmega( Double_t *px, Double_t *dummy )
660{
fdcaa191 661//--------------------------------------------------------------------------
662//
663// omega pt-distribution
664//
665//____________________________________________________________--------------
fdcaa191 666
667 return PtScal(*px,4); // 4==> Omega in the PtScal function
668
669}
f4cd22aa 670Double_t AliGenGSIlib::YOmega(Double_t *py, Double_t *dummy)
671{
fdcaa191 672//--------------------------------------------------------------------------
673//
674// omega y-distribution
675//
676//--------------------------------------------------------------------------
fdcaa191 677
678 const Double_t ka = 1000.;
679 const Double_t kdy = 4.;
680
681
682 Double_t y=TMath::Abs(*py);
683
684 Double_t ex = y*y/(2*kdy*kdy);
685
686 return ka*TMath::Exp(-ex);
687
688}
689//--------------------------------------------------------------------------
690//
691// Rho
692//
693//--------------------------------------------------------------------------
f4cd22aa 694
695Int_t AliGenGSIlib::IpRho(TRandom *)
696{
fdcaa191 697//
698// rho particle composition
699//
700//--------------------------------------------------------------------------
fdcaa191 701
702 return 113;
703
704}
f4cd22aa 705Double_t AliGenGSIlib::PtRho( Double_t *px, Double_t *dummy )
706{
fdcaa191 707//--------------------------------------------------------------------------
708//
709// rho pt-distribution
710//
711//____________________________________________________________--------------
fdcaa191 712
713 return PtScal(*px,11); // 11==> Rho in the PtScal function
714
715}
f4cd22aa 716Double_t AliGenGSIlib::YRho(Double_t *py, Double_t *dummy)
717{
fdcaa191 718//--------------------------------------------------------------------------
719//
720// rho y-distribution
721//
722//--------------------------------------------------------------------------
f4cd22aa 723
fdcaa191 724 const Double_t ka = 1000.;
725 const Double_t kdy = 4.;
726
727
728 Double_t y=TMath::Abs(*py);
729
730 Double_t ex = y*y/(2*kdy*kdy);
731
732 return ka*TMath::Exp(-ex);
733
734}
735//--------------------------------------------------------------------------
736//
737// Pion
738//
739//--------------------------------------------------------------------------
f4cd22aa 740Int_t AliGenGSIlib::IpPionPHOS(TRandom *ran)
741{
fdcaa191 742//
743// particle composition pi+, pi0, pi-
744//
745//--------------------------------------------------------------------------
fdcaa191 746
747 Float_t random = ran->Rndm();
748
749 if ( (3.*random) < 1. )
750 {
751 return 211 ;
752 }
753 else
754 {
755 if ( (3.*random) >= 2.)
756 {
757 return -211 ;
758 }
759 else
760 {
761 return 111 ;
762 }
763 }
764}
f4cd22aa 765Double_t AliGenGSIlib::PtPion( Double_t *px, Double_t *dummy )
766{
fdcaa191 767//--------------------------------------------------------------------------
768//
769// pion pt-distribution
770//
771// Pion transverse momentum distribtuion as in AliGenMUONlib class,
772// version 3.01 of aliroot:
773// PT-PARAMETERIZATION CDF, PRL 61(88) 1819
774// POWER LAW FOR PT > 500 MEV
775// MT SCALING BELOW (T=160 MEV)
776//
777//____________________________________________________________--------------
fdcaa191 778
779 const Double_t kp0 = 1.3;
780 const Double_t kxn = 8.28;
781 const Double_t kxlim=0.5;
782 const Double_t kt=0.160;
783 const Double_t kxmpi=0.139;
784 const Double_t kb=1.;
785 Double_t y, y1, kxmpi2, ynorm, a;
786 Double_t x=*px;
787
788 y1=TMath::Power(kp0/(kp0+kxlim),kxn);
789 kxmpi2=kxmpi*kxmpi;
790 ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+kxmpi2)/kt));
791 a=ynorm/y1;
792 if (x > kxlim)
793 y=a*TMath::Power(kp0/(kp0+x),kxn);
794 else
795 y=kb*TMath::Exp(-sqrt(x*x+kxmpi2)/kt);
796 return y*x;
797
798}
f4cd22aa 799Double_t AliGenGSIlib::YPion(Double_t *py, Double_t *dummy)
800{
fdcaa191 801//--------------------------------------------------------------------------
802//
803// pion y-distribution
804//
805//--------------------------------------------------------------------------
fdcaa191 806
807 const Double_t ka = 7000.;
808 const Double_t kdy = 4.;
809
810 Double_t y=TMath::Abs(*py);
811
812 Double_t ex = y*y/(2*kdy*kdy);
813
814 return ka*TMath::Exp(-ex);
815
816}
f4cd22aa 817Int_t AliGenGSIlib::IpKaonPHOS(TRandom *ran)
818{
fdcaa191 819//--------------------------------------------------------------------------
820//
821//
822// Kaon
823//--------------------------------------------------------------------------
824//
825// kaon particle composition K+, K-, Ko_short, Ko_long
826//
827//--------------------------------------------------------------------------
fdcaa191 828
829 Float_t random = ran->Rndm();
830 Float_t random2 = ran->Rndm();
831 if (random2 < 0.5)
832 {
833 if (random < 0.5) {
834 return 321; // K+
835 } else {
836 return -321; // K-
837 }
838 }
839 else
840 {
841 if (random < 0.5) {
842 return 130; // K^0 short
843 } else {
844 return 310; // K^0 long
845 }
846 }
847}
f4cd22aa 848Double_t AliGenGSIlib::PtKaonPHOS( Double_t *px, Double_t *dummy )
849{
fdcaa191 850//--------------------------------------------------------------------------
851//
852// kaon pt-distribution
853//
854//____________________________________________________________--------------
fdcaa191 855
856 return PtScal(*px,2); // 2==> Kaon in the PtScal function
857
858}
f4cd22aa 859Double_t AliGenGSIlib::YKaonPHOS(Double_t *py, Double_t *dummy)
860{
fdcaa191 861//--------------------------------------------------------------------------
862//
863// kaon y-distribution
864//
865//--------------------------------------------------------------------------
fdcaa191 866
867 const Double_t ka = 1000.;
868 const Double_t kdy = 4.;
869
870 Double_t y=TMath::Abs(*py);
871
872 Double_t ex = y*y/(2*kdy*kdy);
873
874 return ka*TMath::Exp(-ex);
875
876}
877//--------------------------------------------------------------------------
878//
879// Phi
880//
f4cd22aa 881Int_t AliGenGSIlib::IpPhi(TRandom *)
882{
fdcaa191 883//--------------------------------------------------------------------------
884//
885// particle composition
886//
887//--------------------------------------------------------------------------
fdcaa191 888
889 return 333;
890
891}
f4cd22aa 892Double_t AliGenGSIlib::PtPhiPHOS( Double_t *px, Double_t *dummy )
893{
fdcaa191 894//--------------------------------------------------------------------------
895//
896// phi pt-distribution
897//
898//____________________________________________________________--------------
fdcaa191 899
900 return PtScal(*px,6); // 6==> Phi in the PtScal function
901
902}
f4cd22aa 903Double_t AliGenGSIlib::YPhiPHOS(Double_t *py, Double_t *dummy)
904{
fdcaa191 905//--------------------------------------------------------------------------
906//
907// phi y-distribution
908//
909//--------------------------------------------------------------------------
fdcaa191 910
911 const Double_t ka = 1000.;
912 const Double_t kdy = 4.;
913
914
915 Double_t y=TMath::Abs(*py);
916
917 Double_t ex = y*y/(2*kdy*kdy);
918
919 return ka*TMath::Exp(-ex);
920
921}
f4cd22aa 922Int_t AliGenGSIlib::IpBaryons(TRandom *ran)
923{
fdcaa191 924//--------------------------------------------------------------------------
925//
926// Baryons
927//
928//--------------------------------------------------------------------------
929//
930// baryons particle composition p, pbar, n, nbar
931//
932//--------------------------------------------------------------------------
fdcaa191 933
934 Float_t random = ran->Rndm();
935 Float_t random2 = ran->Rndm();
936 if (random2 < 0.5)
937 {
938 if (random < 0.5) {
939 return 2212; // p
940 } else {
941 return -2212; // pbar
942 }
943 }
944 else
945 {
946 if (random < 0.5) {
947 return 2112; // n
948 } else {
949 return -2112; // n bar
950 }
951 }
952}
f4cd22aa 953Double_t AliGenGSIlib::PtBaryons( Double_t *px, Double_t *dummy )
954{
fdcaa191 955//--------------------------------------------------------------------------
956//
957// baryons pt-distribution
958//
959//____________________________________________________________--------------
fdcaa191 960
961 return PtScal(*px,7); // 7==> Baryon in the PtScal function
962
963}
f4cd22aa 964Double_t AliGenGSIlib::YBaryons(Double_t *py, Double_t *dummy)
965{
fdcaa191 966//--------------------------------------------------------------------------
967//
968// baryons y-distribution
969//
970//--------------------------------------------------------------------------
fdcaa191 971
972 const Double_t ka = 1000.;
973 const Double_t kdy = 4.;
974
975 Double_t y=TMath::Abs(*py);
976
977 Double_t ex = y*y/(2*kdy*kdy);
978
979 return ka*TMath::Exp(-ex);
980
981}
982//=============================================================
983//
984// Mt-scaling as in AliGenPHOSlib
985//
986//=============================================================
987//
988 Double_t AliGenGSIlib::PtScal(Double_t pt, Int_t np)
989{
990// Function for the calculation of the Pt distribution for a
991// given particle np, from the pion Pt distribution using the
992// mt scaling.
993
994// It was taken from AliGenPHOSlib aliroot version 3.04, which
995// is an update of the one in AliGenMUONlib aliroot version 3.01
996// with an extension for Baryons but supressing Rhos
997// np = 1=>Pions 2=>Kaons 3=>Etas 4=>Omegas 5=>ETA' 6=>PHI
998// 7=>BARYONS-BARYONBARS
999
1000// The present adds the Rhos
1001
1002// MASS 1=>PI, 2=>K, 3=>ETA, 4=>OMEGA, 5=>ETA', 6=>PHI
1003// 7=>BARYON-BARYONBAR, 11==>RHO
1004
1005 const Double_t khm[11] = {0.1396, 0.494, 0.547, 0.782, 0.957, 1.02,
1006 0.938, 0. , 0., 0., 0.769};
1007
1008 // VALUE MESON/PI AT 5 GEV
1009
1010 const Double_t kfmax[11]={1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.};
1011
1012 np--;
1013 Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
1014 Double_t kfmax2=f5/kfmax[np];
1015 // PIONS
1016 Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
1017 Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
1018 (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ kfmax2;
1019 return fmtscal*ptpion;
1020}
1021
1022//==========================================================================
1023//
1024// Set Getters
1025//
1026//==========================================================================
1027
1028typedef Double_t (*GenFunc) (Double_t*, Double_t*);
1029
1030typedef Int_t (*GenFuncIp) (TRandom *);
014616eb 1031
f4cd22aa 1032GenFunc AliGenGSIlib::GetPt(Int_t param, const char * tname) const
014616eb 1033{
1034// Return pointer to pT parameterisation
fdcaa191 1035 GenFunc func=0;
1036 TString sname(tname);
1037
1038 switch (param)
014616eb 1039 {
34f60c01 1040 case kUpsilon:
fdcaa191 1041 if (sname=="FLAT"){
1042 func= PtUpsilonFlat;
1043 break;
1044 }
014616eb 1045 if (sname=="MUON"){
1046 func= PtUpsilonMUON;
1047 break;
1048 }
1049 if (sname=="RITMAN"){
1050 func=PtUpsilonRitman;
1051 break;
1052 }
1053 if (sname=="KAREL"){
1054 func=PtUpsilonKarel;
1055 break;
1056 }
1057 break;
1058 func=0;
1059 printf("<AliGenGSIlib::GetPt> unknown parametrisation\n");
fdcaa191 1060
1061 case kJPsi:
1062 if (sname=="FLAT"){
1063 func= PtJpsiFlat;
1064 break;
1065 }
1066 if (sname=="MUON"){
1067 func= PtJpsiMUON;
1068 break;
1069 }
1070 // if (sname=="SERGEI"){
1071 // func= PtJpsi;
1072 // break;
1073 // }
1074 break;
1075 func=0;
1076 printf("<AliGenGSIlib::GetPt> unknown parametrisation\n");
1077
1078 case kCharm:
1079 if (sname=="FLAT"){
1080 func= PtCharmFlat;
1081 break;
1082 }
1083
1084 if (sname=="MUON"){
1085 func= PtCharmMUON;
1086 break;
1087 }
1088
1089 if (sname=="GSI"){
1090 func= PtCharmGSI;
1091 break;
1092 }
1093 break;
1094 func=0;
1095 printf("<AliGenGSIlib::GetPt> unknown parametrisation\n");
1096
1097 case kBeauty:
1098 if (sname=="FLAT"){
1099 func= PtBeautyFlat;
1100 break;
1101 }
1102 if (sname=="MUON"){
1103 func= PtBeautyMUON;
1104 break;
1105 }
1106 if (sname=="GSI"){
1107 func= PtBeautyGSI;
1108 break;
1109 }
1110 break;
1111 func=0;
1112 printf("<AliGenGSIlib::GetPt> unknown parametrisation\n");
1113
1114
1115 case kEta:
1116 func=PtEtaPHOS;
1117 break;
1118
1119 case kEtaprime:
1120 func=PtEtaprimePHOS;
1121 break;
1122
1123 case kOmega:
1124 func=PtOmega;
1125 break;
1126
1127 case kRho:
1128 func=PtRho;
1129 break;
1130
1131 case kKaon:
1132 func=PtKaonPHOS;
1133 break;
1134
1135 case kPion:
1136 func=PtPion;
1137 break;
1138
1139 case kPhi:
1140 func=PtPhiPHOS;
1141 break;
1142
1143 // case kLambda:
1144 // func=PtLambda;
1145 // break;
1146
1147 case kBaryons:
1148 func=PtBaryons;
1149 break;
1150
014616eb 1151 default:
1152 func=0;
1153 printf("<AliGenGSIlib::GetPt> unknown parametrisation\n");
1154 }
1155 return func;
1156}
1157
f4cd22aa 1158GenFunc AliGenGSIlib::GetY(Int_t param, const char * tname) const
014616eb 1159{
fdcaa191 1160// Return pointer to y- parameterisation
014616eb 1161 GenFunc func=0;
fdcaa191 1162 TString sname(tname);
1163
1164 switch (param)
014616eb 1165 {
34f60c01 1166 case kUpsilon:
fdcaa191 1167 if (sname=="FLAT"){
1168 func= YUpsilonFlat;
1169 break;
1170 }
014616eb 1171 if (sname=="MUON"){
1172 func= YUpsilonMUON;
1173 break;
1174 }
1175 if (sname=="RITMAN"){
1176 func=YUpsilonRitman;
1177 break;
1178 }
1179 if (sname=="KAREL"){
1180 func=YUpsilonKarel;
1181 break;
1182 }
1183 func=0;
1184 printf("<AliGenGSIlib::GetY> unknown parametrisation\n");
1185 break;
fdcaa191 1186
1187 case kJPsi:
1188 if (sname=="FLAT"){
1189 func= YJpsiFlat;
1190 break;
1191 }
1192 if (sname=="MUON"){
1193 func= YJpsiMUON;
1194 break;
1195 }
1196 // if (sname=="SERGEI"){
1197 // func= YJpsi;
1198 // break;
1199 // }
1200
1201 func=0;
1202 printf("<AliGenGSIlib::GetY> unknown parametrisation\n");
1203 break;
1204
1205 case kCharm:
1206 func= YCharm;
1207 break;
1208
1209 case kBeauty:
1210 func= YBeauty;
1211 break;
1212
1213 case kEta:
1214 func=YEtaPHOS;
1215 break;
1216
1217 case kEtaprime:
1218 func=YEtaprimePHOS;
1219 break;
1220
1221 case kOmega:
1222 func=YOmega;
1223 break;
1224
1225 case kRho:
1226 func=YRho;
1227 break;
1228
1229 case kKaon:
1230 func=YKaonPHOS;
1231 break;
1232
1233 case kPion:
1234 func=YPion;
1235 break;
1236
1237 case kPhi:
1238 func=YPhiPHOS;
1239 break;
1240
1241 // case kLambda:
1242 // func=YLambda;
1243 // break;
1244
1245 case kBaryons:
1246 func=YBaryons;
1247 break;
1248
014616eb 1249 default:
1250 func=0;
1251 printf("<AliGenGSIlib::GetY> unknown parametrisation\n");
1252 }
1253 return func;
1254}
1255
f4cd22aa 1256GenFuncIp AliGenGSIlib::GetIp(Int_t param, const char * tname) const
014616eb 1257{
1258// Return pointer to particle type parameterisation
fdcaa191 1259 GenFuncIp func=0;
1260 TString sname(tname);
1261
1262 switch (param)
014616eb 1263 {
34f60c01 1264 case kUpsilon:
fdcaa191 1265 func= IpUpsilon;
014616eb 1266 break;
fdcaa191 1267
1268 case kJPsi:
1269 func= IpJpsi;
014616eb 1270 break;
fdcaa191 1271
1272 case kCharm:
1273 func= IpCharm;
014616eb 1274 break;
fdcaa191 1275
1276 case kBeauty:
1277 func= IpBeauty;
1278 break;
1279
1280 case kEta:
1281 func=IpEta;
1282 break;
1283
1284 case kEtaprime:
1285 func=IpEtaprime;
1286 break;
1287
1288 case kOmega:
1289 func=IpOmega;
1290 break;
1291
1292 case kRho:
1293 func=IpRho;
1294 break;
1295
1296 case kKaon:
1297 func=IpKaonPHOS;
1298 break;
1299
1300 case kPion:
1301 func=IpPionPHOS;
1302 break;
1303
1304 case kPhi:
1305 func=IpPhi;
1306 break;
1307
1308 // case kLambda:
1309 // func=IpLambda;
1310 // break;
1311
1312 case kBaryons:
1313 func=IpBaryons;
1314 break;
1315
014616eb 1316 default:
1317 func=0;
1318 printf("<AliGenGSIlib::GetIp> unknown parametrisation\n");
1319 }
1320 return func;
1321}
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333