EVGEN/AliGenSTRANGElib.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 //======================================================================
  18 //  AliGenSTRANGElib class contains parameterizations of the
  19 //  kaon, phi and hyperon (Lambda, Anti-Lambda, Xi, anti-Xi, Omega,
  20 //  anti-Omega)  for the PPR study of the strange particle production.
  21 //  These parameterizations are used by the
  22 //  AliGenParam  class:
  23 //  AliGenParam(npar, param,  AliGenSTRANGElib::GetPt(param),
  24 //                            AliGenSTRANGElib::GetY(param),
  25 //                            AliGenSTRANGElib::GetIp(param) )
  26 //  param represents the particle to be simulated.
  27 //  ?????????
  28 //  Pt distributions are calculated from the transverse mass scaling
  29 //  with Pions, using the PtScal function taken from AliGenMUONlib
  30 //  version aliroot 3.01
  31 //
  32 //     Rocco CALIANDRO. Rosa Anna FINI, Tiziano VIRGILI
  33 //     Rocco.Caliandro@cern.ch Rosanna.Fini@ba.infn.it,
  34 //     Tiziano.Virgili@roma1.infn.it
  35 //======================================================================
  36
  37 /*
  38 $Log$
  39 */
  40
  41 #include "TMath.h"
  42 #include "TRandom.h"
  43
  44 #include "AliGenSTRANGElib.h"
  45
  46 ClassImp(AliGenSTRANGElib)
  47
  48 //=============================================================
  49 //
  50  Double_t AliGenSTRANGElib::PtScal(Double_t pt, Int_t np)
  51 {
  52 // Mt-scaling
  53 // Function for the calculation of the Pt distribution for a
  54 // given particle np, from the pion Pt distribution using the
  55 // mt scaling. This function was taken from AliGenMUONlib
  56 // aliroot version 3.01, and was extended for hyperons.
  57 // np = 1=>Pions 2=>Kaons 3=>Etas 4=>Omegas 5=>ETA' 6=>PHI
  58 //      7=>BARYONS-BARYONBARS
  59 //      8=>Lambda-antiLambda
  60 //      9=>Xi-antiXi
  61 //     10=>Omega-antiOmega
  62
  63   //    MASS SCALING RESPECT TO PIONS
  64   //    MASS                1=>PI,  2=>K, 3=>ETA,4=>OMEGA,5=>ETA',6=>PHI
  65   const Double_t khm[10] = {0.1396, 0.494,0.547, 0.782,   0.957,  1.02,
  66   //    MASS               7=>BARYON-BARYONBAR
  67                                  0.938,
  68   //    MASS               8=>Lambda-antiLambda
  69                                   1.1157,
  70   //    MASS               9=>Xi-antiXi
  71                                   1.3213,
  72   //    MASS              10=>Omega-antiOmega
  73                                   1.6725};
  74   //     VALUE MESON/PI AT 5 GEV
  75   const Double_t kfmax[10]={1., 1., 1., 1., 1., 1., 1., 1., 1., 1.};
  76   np--;
  77   Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
  78   Double_t kfmax2=f5/kfmax[np];
  79   // PIONS
  80   Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
  81   Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
  82                                  (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ kfmax2;
  83   return fmtscal*ptpion;
  84 }
  85 //=============================================================
  86 //
  87  Double_t AliGenSTRANGElib::PtPion(Double_t *px, Double_t *)
  88 {
  89 //     Pion transverse momentum distribtuion taken
  90 //     from AliGenMUONlib class, version 3.01 of aliroot
  91 //     PT-PARAMETERIZATION CDF, PRL 61(88) 1819
  92 //     POWER LAW FOR PT > 500 MEV
  93 //     MT SCALING BELOW (T=160 MEV)
  94 //
  95   const Double_t kp0 = 1.3;
  96   const Double_t kxn = 8.28;
  97   const Double_t kxlim=0.5;
  98   const Double_t kt=0.160;
  99   const Double_t kxmpi=0.139;
 100   const Double_t kb=1.;
 101   Double_t y, y1, kxmpi2, ynorm, a;
 102   Double_t x=*px;
 103   //
 104   y1=TMath::Power(kp0/(kp0+kxlim),kxn);
 105   kxmpi2=kxmpi*kxmpi;
 106   ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+kxmpi2)/kt));
 107   a=ynorm/y1;
 108   if (x > kxlim)
 109     y=a*TMath::Power(kp0/(kp0+x),kxn);
 110   else
 111     y=kb*TMath::Exp(-sqrt(x*x+kxmpi2)/kt);
 112   return y*x;
 113 }
 114 // End Scaling
 115 //============================================================================
 116 //    K  A  O  N
 117  Double_t AliGenSTRANGElib::PtKaon( Double_t *px, Double_t *)
 118 {
 119 //                kaon
 120 //                pt-distribution
 121 //____________________________________________________________
 122
 123   return PtScal(*px,2);  //  2==> Kaon in the PtScal function
 124 }
 125
 126  Double_t AliGenSTRANGElib::YKaon( Double_t *py, Double_t *)
 127 {
 128 // y-distribution
 129 //____________________________________________________________
 130
 131   const Double_t ka    = 1000.;
 132   const Double_t kdy   = 4.;
 133
 134
 135   Double_t y=TMath::Abs(*py);
 136   //
 137   Double_t ex = y*y/(2*kdy*kdy);
 138   return ka*TMath::Exp(-ex);
 139 }
 140
 141  Int_t AliGenSTRANGElib::IpKaon(TRandom *ran)
 142 {
 143 //                 particle composition
 144 //
 145
 146     Float_t random = ran->Rndm();
 147     Float_t random2 = ran->Rndm();
 148     if (random2 < 0.5)
 149     {
 150       if (random < 0.5) {
 151         return  321;   //   K+
 152       } else {
 153         return -321;   // K-
 154       }
 155     }
 156     else
 157     {
 158       if (random < 0.5) {
 159         return  130;   // K^0 short
 160       } else {
 161         return  310;   // K^0 long
 162       }
 163     }
 164 }
 165 // End Kaons
 166 //============================================================================
 167 //============================================================================
 168 //    P  H  I
 169  Double_t AliGenSTRANGElib::PtPhi( Double_t *px, Double_t *)
 170 {
 171 // phi
 172 //                pt-distribution
 173 //____________________________________________________________
 174
 175   return PtScal(*px,6);  //  6==> Phi in the PtScal function
 176 }
 177
 178  Double_t AliGenSTRANGElib::YPhi( Double_t *py, Double_t *)
 179 {
 180 // y-distribution
 181 //____________________________________________________________
 182
 183   const Double_t ka    = 1000.;
 184   const Double_t kdy   = 4.;
 185
 186
 187   Double_t y=TMath::Abs(*py);
 188   //
 189   Double_t ex = y*y/(2*kdy*kdy);
 190   return ka*TMath::Exp(-ex);
 191 }
 192
 193  Int_t AliGenSTRANGElib::IpPhi(TRandom *)
 194 {
 195 //                 particle composition
 196 //
 197
 198         return  333;   //   Phi
 199 }
 200 // End Phis
 201 //===================================================================
 202 //============================================================================
 203 //    Lambda
 204  Double_t AliGenSTRANGElib::PtLambda( Double_t *px, Double_t *)
 205 {
 206 // Lambda
 207 //                pt-distribution
 208 //____________________________________________________________
 209
 210   return PtScal(*px,8);  //  8==> Lambda-antiLambda in the PtScal function
 211 }
 212
 213  Double_t AliGenSTRANGElib::YLambda( Double_t *py, Double_t *)
 214 {
 215 // y-distribution
 216 //____________________________________________________________
 217
 218   const Double_t ka    = 1000.;
 219   const Double_t kdy   = 4.;
 220
 221
 222   Double_t y=TMath::Abs(*py);
 223   //
 224   Double_t ex = y*y/(2*kdy*kdy);
 225   return ka*TMath::Exp(-ex);
 226 }
 227
 228  Int_t AliGenSTRANGElib::IpLambda(TRandom *)
 229 {
 230 //                 particle composition
 231 //                 generation of fixed type of particle
 232 //
 233
 234         return  3122; //   Lambda
 235 }
 236 // End Lambda
 237 //============================================================================
 238 //    XIminus
 239  Double_t AliGenSTRANGElib::PtXiMinus( Double_t *px, Double_t *)
 240 {
 241 // Xi
 242 //                pt-distribution
 243 //____________________________________________________________
 244
 245   return PtScal(*px,9);  //  9==> Xi-antiXi in the PtScal function
 246 }
 247
 248  Double_t AliGenSTRANGElib::YXiMinus( Double_t *py, Double_t *)
 249 {
 250 // y-distribution
 251 //____________________________________________________________
 252
 253   const Double_t ka    = 1000.;
 254   const Double_t kdy   = 4.;
 255
 256
 257   Double_t y=TMath::Abs(*py);
 258   //
 259   Double_t ex = y*y/(2*kdy*kdy);
 260   return ka*TMath::Exp(-ex);
 261 }
 262
 263  Int_t AliGenSTRANGElib::IpXiMinus(TRandom *)
 264 {
 265 //                 particle composition
 266 //                 generation of fixed type of particle
 267 //
 268
 269         return  3312; //   Xi- (only)
 270 //        return  -3312; //   Xi+
 271 }
 272 // End Ximinus
 273 //============================================================================
 274 //    Omegaminus
 275  Double_t AliGenSTRANGElib::PtOmegaMinus( Double_t *px, Double_t *)
 276 {
 277 // Omega
 278 //                pt-distribution
 279 //____________________________________________________________
 280
 281   return PtScal(*px,10);  //  10==> Omega-antiOmega in the PtScal function
 282 }
 283
 284  Double_t AliGenSTRANGElib::YOmegaMinus( Double_t *py, Double_t *)
 285 {
 286 // y-distribution
 287 //____________________________________________________________
 288
 289   const Double_t ka    = 1000.;
 290   const Double_t kdy   = 4.;
 291
 292
 293   Double_t y=TMath::Abs(*py);
 294   //
 295   Double_t ex = y*y/(2*kdy*kdy);
 296   return ka*TMath::Exp(-ex);
 297 }
 298
 299  Int_t AliGenSTRANGElib::IpOmegaMinus(TRandom *)
 300 {
 301 //                 particle composition
 302 //                 generation of fixed type of particle
 303 //
 304
 305         return  3334; //   Omega-
 306 }
 307 // End Omegaminus
 308 //============================================================================
 309
 310
 311 typedef Double_t (*GenFunc) (Double_t*,  Double_t*);
 312  GenFunc AliGenSTRANGElib::GetPt(Int_t param, const char* tname)
 313 {
 314 // Return pinter to pT parameterisation
 315     GenFunc func;
 316
 317     switch (param)
 318     {
 319     case kKaon:
 320         func=PtKaon;
 321         break;
 322     case kPhi:
 323         func=PtPhi;
 324         break;
 325     case kLambda:
 326         func=PtLambda;
 327         break;
 328     case kXiMinus:
 329         func=PtXiMinus;
 330         break;
 331     case kOmegaMinus:
 332         func=PtOmegaMinus;
 333         break;
 334     default:
 335         func=0;
 336         printf("<AliGenSTRANGElib::GetPt> unknown parametrisationn");
 337     }
 338     return func;
 339 }
 340
 341  GenFunc AliGenSTRANGElib::GetY(Int_t param, const char* tname)
 342 {
 343 // Return pointer to Y parameterisation
 344     GenFunc func;
 345     switch (param)
 346     {
 347     case kKaon:
 348         func=YKaon;
 349         break;
 350     case kPhi:
 351         func=YPhi;
 352         break;
 353     case kLambda:
 354         func=YLambda;
 355         break;
 356     case kXiMinus:
 357         func=YXiMinus;
 358         break;
 359     case kOmegaMinus:
 360         func=YOmegaMinus;
 361         break;
 362     default:
 363         func=0;
 364         printf("<AliGenSTRANGElib::GetY> unknown parametrisationn");
 365     }
 366     return func;
 367 }
 368 typedef Int_t (*GenFuncIp) (TRandom *);
 369  GenFuncIp AliGenSTRANGElib::GetIp(Int_t param,  const char* tname)
 370 {
 371 // Return pointer to particle composition
 372     GenFuncIp func;
 373     switch (param)
 374     {
 375     case kKaon:
 376         func=IpKaon;
 377         break;
 378     case kPhi:
 379         func=IpPhi;
 380         break;
 381     case kLambda:
 382         func=IpLambda;
 383         break;
 384     case kXiMinus:
 385         func=IpXiMinus;
 386         break;
 387     case kOmegaMinus:
 388         func=IpOmegaMinus;
 389         break;
 390     default:
 391         func=0;
 392         printf("<AliGenSTRANGElib::GetIp> unknown parametrisationn");
 393     }
 394     return func;
 395 }
 396