EVGEN/AliGenMUONlib.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 /*
  17 $Log$
  18 Revision 1.9  2000/06/14 15:20:56  morsch
  19 Include clean-up (IH)
  20
  21 Revision 1.8  2000/06/09 20:32:11  morsch
  22 All coding rule violations except RS3 corrected
  23
  24 Revision 1.7  2000/05/02 08:12:13  morsch
  25 Coding rule violations corrected.
  26
  27 Revision 1.6  1999/09/29 09:24:14  fca
  28 Introduction of the Copyright and cvs Log
  29
  30 */
  31
  32 #include "AliGenMUONlib.h"
  33 #include "AliMC.h"
  34
  35 ClassImp(AliGenMUONlib)
  36 //
  37 //  Pions
  38 Double_t AliGenMUONlib::PtPion(Double_t *px, Double_t *dummy)
  39 {
  40 //
  41 //     PT-PARAMETERIZATION CDF, PRL 61(88) 1819
  42 //     POWER LAW FOR PT > 500 MEV
  43 //     MT SCALING BELOW (T=160 MEV)
  44 //
  45   const Double_t kp0 = 1.3;
  46   const Double_t kxn = 8.28;
  47   const Double_t kxlim=0.5;
  48   const Double_t kt=0.160;
  49   const Double_t kxmpi=0.139;
  50   const Double_t kb=1.;
  51   Double_t y, y1, xmpi2, ynorm, a;
  52   Double_t x=*px;
  53   //
  54   y1=TMath::Power(kp0/(kp0+kxlim),kxn);
  55   xmpi2=kxmpi*kxmpi;
  56   ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+xmpi2)/kt));
  57   a=ynorm/y1;
  58   if (x > kxlim)
  59     y=a*TMath::Power(kp0/(kp0+x),kxn);
  60   else
  61     y=kb*TMath::Exp(-sqrt(x*x+xmpi2)/kt);
  62   return y*x;
  63 }
  64 //
  65 // y-distribution
  66 //
  67 Double_t AliGenMUONlib::YPion( Double_t *py, Double_t *dummy)
  68 {
  69 // Pion y
  70   const Double_t ka    = 7000.;
  71   const Double_t kdy   = 4.;
  72
  73   Double_t y=TMath::Abs(*py);
  74   //
  75   Double_t ex = y*y/(2*kdy*kdy);
  76   return ka*TMath::Exp(-ex);
  77 }
  78 //                 particle composition
  79 //
  80 Int_t AliGenMUONlib::IpPion()
  81 {
  82 // Pion composition
  83     Float_t random[1];
  84     gMC->Rndm(random,1);
  85     if (random[0] < 0.5) {
  86         return  211;
  87     } else {
  88         return -211;
  89     }
  90 }
  91
  92 //____________________________________________________________
  93 //
  94 // Mt-scaling
  95
  96 Double_t AliGenMUONlib::PtScal(Double_t pt, Int_t np)
  97 {
  98   //    SCALING EN MASSE PAR RAPPORT A PTPI
  99   //    MASS PI,K,ETA,RHO,OMEGA,ETA',PHI
 100   const Double_t khm[10] = {.13957,.493,.5488,.769,.7826,.958,1.02,0,0,0};
 101   //     VALUE MESON/PI AT 5 GEV
 102   const Double_t kfmax[10]={1.,0.3,0.55,1.0,1.0,1.0,1.0,0,0,0};
 103   np--;
 104   Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
 105   Double_t fmax2=f5/kfmax[np];
 106   // PIONS
 107   Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
 108   Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
 109                                  (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ fmax2;
 110   return fmtscal*ptpion;
 111 }
 112 //
 113 // kaon
 114 //
 115 //                pt-distribution
 116 //____________________________________________________________
 117 Double_t AliGenMUONlib::PtKaon( Double_t *px, Double_t *dummy)
 118 {
 119 // Kaon pT
 120   return PtScal(*px,2);
 121 }
 122
 123 // y-distribution
 124 //____________________________________________________________
 125 Double_t AliGenMUONlib::YKaon( Double_t *py, Double_t *dummy)
 126 {
 127 // Kaon y
 128   const Double_t ka    = 1000.;
 129   const Double_t kdy   = 4.;
 130
 131
 132   Double_t y=TMath::Abs(*py);
 133   //
 134   Double_t ex = y*y/(2*kdy*kdy);
 135   return ka*TMath::Exp(-ex);
 136 }
 137
 138 //                 particle composition
 139 //
 140 Int_t AliGenMUONlib::IpKaon()
 141 {
 142 // Kaon composition
 143     Float_t random[1];
 144     gMC->Rndm(random,1);
 145     if (random[0] < 0.5) {
 146         return  321;
 147     } else {
 148         return -321;
 149     }
 150 }
 151
 152 //                    J/Psi
 153 //
 154 //
 155 //                pt-distribution
 156 //____________________________________________________________
 157 Double_t AliGenMUONlib::PtJpsi( Double_t *px, Double_t *dummy)
 158 {
 159 // J/Psi pT
 160   const Double_t kpt0 = 4.;
 161   const Double_t kxn  = 3.6;
 162   Double_t x=*px;
 163   //
 164   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
 165   return x/TMath::Power(pass1,kxn);
 166 }
 167 //
 168 //               y-distribution
 169 //____________________________________________________________
 170 Double_t AliGenMUONlib::YJpsi(Double_t *py, Double_t *dummy)
 171 {
 172 // J/psi y
 173   const Double_t ky0 = 4.;
 174   const Double_t kb=1.;
 175   Double_t yj;
 176   Double_t y=TMath::Abs(*py);
 177   //
 178   if (y < ky0)
 179     yj=kb;
 180   else
 181     yj=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
 182   return yj;
 183 }
 184 //                 particle composition
 185 //
 186 Int_t AliGenMUONlib::IpJpsi()
 187 {
 188 // J/Psi composition
 189     return 443;
 190 }
 191
 192 //                      Upsilon
 193 //
 194 //
 195 //                  pt-distribution
 196 //____________________________________________________________
 197 Double_t AliGenMUONlib::PtUpsilon( Double_t *px, Double_t *dummy )
 198 {
 199 // Upsilon pT
 200   const Double_t kpt0 = 5.3;
 201   const Double_t kxn  = 2.5;
 202   Double_t x=*px;
 203   //
 204   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
 205   return x/TMath::Power(pass1,kxn);
 206 }
 207 //
 208 //                    y-distribution
 209 //
 210 //____________________________________________________________
 211 Double_t AliGenMUONlib::YUpsilon(Double_t *py, Double_t *dummy)
 212 {
 213 // Upsilon y
 214   const Double_t ky0 = 3.;
 215   const Double_t kb=1.;
 216   Double_t yu;
 217   Double_t y=TMath::Abs(*py);
 218   //
 219   if (y < ky0)
 220     yu=kb;
 221   else
 222     yu=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
 223   return yu;
 224 }
 225 //                 particle composition
 226 //
 227 Int_t AliGenMUONlib::IpUpsilon()
 228 {
 229 // y composition
 230     return 553;
 231 }
 232
 233 //
 234 //                        Phi
 235 //
 236 //
 237 //    pt-distribution (by scaling of pion distribution)
 238 //____________________________________________________________
 239 Double_t AliGenMUONlib::PtPhi( Double_t *px, Double_t *dummy)
 240 {
 241 // Phi pT
 242   return PtScal(*px,7);
 243 }
 244 //    y-distribution
 245 Double_t AliGenMUONlib::YPhi( Double_t *px, Double_t *dummy)
 246 {
 247 // Phi y
 248     Double_t *dum=0;
 249     return YJpsi(px,dum);
 250 }
 251 //                 particle composition
 252 //
 253 Int_t AliGenMUONlib::IpPhi()
 254 {
 255 // Phi composition
 256     return 41;
 257 }
 258
 259 //
 260 //                        Charm
 261 //
 262 //
 263 //                    pt-distribution
 264 //____________________________________________________________
 265 Double_t AliGenMUONlib::PtCharm( Double_t *px, Double_t *dummy)
 266 {
 267 // Charm pT
 268   const Double_t kpt0 = 4.08;
 269   const Double_t kxn  = 9.40;
 270   Double_t x=*px;
 271   //
 272   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
 273   return x/TMath::Power(pass1,kxn);
 274 }
 275 //                  y-distribution
 276 Double_t AliGenMUONlib::YCharm( Double_t *px, Double_t *dummy)
 277 {
 278 // Charm y
 279     Double_t *dum=0;
 280     return YJpsi(px,dum);
 281 }
 282
 283 Int_t AliGenMUONlib::IpCharm()
 284 {
 285 // Charm composition
 286     Float_t random[2];
 287     Int_t ip;
 288 //    411,421,431,4122
 289     gMC->Rndm(random,2);
 290     if (random[0] < 0.5) {
 291         ip=411;
 292     } else if (random[0] < 0.75) {
 293         ip=421;
 294     } else if (random[0] < 0.90) {
 295         ip=431;
 296     } else {
 297         ip=4122;
 298     }
 299     if (random[1] < 0.5) {ip=-ip;}
 300
 301     return ip;
 302 }
 303
 304
 305 //
 306 //                        Beauty
 307 //
 308 //
 309 //                    pt-distribution
 310 //____________________________________________________________
 311 Double_t AliGenMUONlib::PtBeauty( Double_t *px, Double_t *dummy)
 312 {
 313 // Beauty pT
 314   const Double_t kpt0 = 4.;
 315   const Double_t kxn  = 3.6;
 316   Double_t x=*px;
 317   //
 318   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
 319   return x/TMath::Power(pass1,kxn);
 320 }
 321 //                     y-distribution
 322 Double_t AliGenMUONlib::YBeauty( Double_t *px, Double_t *dummy)
 323 {
 324 // Beauty y
 325     Double_t *dum=0;
 326     return YJpsi(px,dum);
 327 }
 328
 329 Int_t AliGenMUONlib::IpBeauty()
 330 {
 331 // Beauty Composition
 332     Float_t random[2];
 333     Int_t ip;
 334     gMC->Rndm(random,2);
 335     if (random[0] < 0.5) {
 336         ip=511;
 337     } else if (random[0] < 0.75) {
 338         ip=521;
 339     } else if (random[0] < 0.90) {
 340         ip=531;
 341     } else {
 342         ip=5122;
 343     }
 344     if (random[1] < 0.5) {ip=-ip;}
 345
 346     return ip;
 347 }
 348
 349 typedef Double_t (*GenFunc) (Double_t*,  Double_t*);
 350 GenFunc AliGenMUONlib::GetPt(Param_t param,  const char* tname)
 351 {
 352 // Return pointer to pT parameterisation
 353     GenFunc func;
 354     switch (param)
 355     {
 356     case phi_p:
 357         func=PtPhi;
 358         break;
 359     case jpsi_p:
 360         func=PtJpsi;
 361         break;
 362     case upsilon_p:
 363         func=PtUpsilon;
 364         break;
 365     case charm_p:
 366         func=PtCharm;
 367         break;
 368     case beauty_p:
 369         func=PtBeauty;
 370         break;
 371     case pion_p:
 372         func=PtPion;
 373         break;
 374     case kaon_p:
 375         func=PtKaon;
 376         break;
 377     default:
 378         func=0;
 379         printf("<AliGenMUONlib::GetPt> unknown parametrisation\n");
 380     }
 381     return func;
 382 }
 383
 384 GenFunc AliGenMUONlib::GetY(Param_t param, const char* tname)
 385 {
 386 // Return pointer to y- parameterisation
 387     GenFunc func;
 388     switch (param)
 389     {
 390     case phi_p:
 391         func=YPhi;
 392         break;
 393     case jpsi_p:
 394         func=YJpsi;
 395         break;
 396     case upsilon_p:
 397         func=YUpsilon;
 398         break;
 399     case charm_p:
 400         func=YCharm;
 401         break;
 402     case beauty_p:
 403         func=YBeauty;
 404         break;
 405     case pion_p:
 406         func=YPion;
 407         break;
 408     case kaon_p:
 409         func=YKaon;
 410         break;
 411     default:
 412         func=0;
 413         printf("<AliGenMUONlib::GetY> unknown parametrisation\n");
 414     }
 415     return func;
 416 }
 417 typedef Int_t (*GenFuncIp) ();
 418 GenFuncIp AliGenMUONlib::GetIp(Param_t param,  const char* tname)
 419 {
 420 // Return pointer to particle type parameterisation
 421     GenFuncIp func;
 422     switch (param)
 423     {
 424     case phi_p:
 425         func=IpPhi;
 426         break;
 427     case jpsi_p:
 428         func=IpJpsi;
 429         break;
 430     case upsilon_p:
 431         func=IpUpsilon;
 432         break;
 433     case charm_p:
 434         func=IpCharm;
 435         break;
 436     case beauty_p:
 437         func=IpBeauty;
 438         break;
 439     case pion_p:
 440         func=IpPion;
 441         break;
 442     case kaon_p:
 443         func=IpKaon;
 444         break;
 445     default:
 446         func=0;
 447         printf("<AliGenMUONlib::GetIp> unknown parametrisation\n");
 448     }
 449     return func;
 450 }
 451
 452
 453
 454