EVGEN/AliGenEMlib.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: AliGenEMlib.cxx 30052 2008-11-25 14:54:18Z morsch $ */
  17
  18 /////////////////////////////////////////////////////////////////////////////
  19 //                                                                         //
  20 // Implementation of AliGenEMlib for electron, di-electron, and photon     //
  21 // cocktail calculations.                                                  //
  22 // It is based on AliGenGSIlib.                                            //
  23 //                                                                         //
  24 // Responsible: R.Averbeck@gsi.de                                          //
  25 //                                                                         //
  26 /////////////////////////////////////////////////////////////////////////////
  27
  28
  29 #include "TMath.h"
  30 #include "TRandom.h"
  31 #include "TString.h"
  32 #include "AliGenEMlib.h"
  33
  34
  35 ClassImp(AliGenEMlib)
  36
  37 //==========================================================================
  38 //
  39 //              Definition of Particle Distributions
  40 //
  41 //==========================================================================
  42
  43 //--------------------------------------------------------------------------
  44 //
  45 //                              Pizero
  46 //
  47 //--------------------------------------------------------------------------
  48 Int_t AliGenEMlib::IpPizero(TRandom *)
  49 {
  50 // Return pizero pdg code
  51   return 111;
  52 }
  53
  54 Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
  55 {
  56 // Generate pizero pT distribution from modified Hagedorn parameterization
  57 // taken from fit to unidentified hadrons in pp at 7 TeV
  58   const Double_t kc=0.000565;
  59   const Double_t kp0=0.2472;
  60   const Double_t kp1=4.354;
  61   const Double_t kn=7.007;
  62   Double_t invYield;
  63   Double_t x=*px;
  64
  65   invYield = kc/TMath::Power(kp0+x/kp1,kn);
  66
  67   return invYield*(2*TMath::Pi()*x);
  68
  69 }
  70
  71 Double_t AliGenEMlib::YPizero( const Double_t *py, const Double_t */*dummy*/ )
  72 {
  73   return YFlat(*py);
  74
  75 }
  76
  77 //--------------------------------------------------------------------------
  78 //
  79 //                              Eta
  80 //
  81 //--------------------------------------------------------------------------
  82 Int_t AliGenEMlib::IpEta(TRandom *)
  83 {
  84 // Return eta pdg code
  85   return 221;
  86 }
  87
  88 Double_t AliGenEMlib::PtEta( const Double_t *px, const Double_t */*dummy*/ )
  89 {
  90 // Eta pT
  91   return MtScal(*px,1);
  92 }
  93
  94 Double_t AliGenEMlib::YEta( const Double_t *py, const Double_t */*dummy*/ )
  95 {
  96   return YFlat(*py);
  97
  98 }
  99
 100 //--------------------------------------------------------------------------
 101 //
 102 //                              Rho
 103 //
 104 //--------------------------------------------------------------------------
 105 Int_t AliGenEMlib::IpRho(TRandom *)
 106 {
 107 // Return rho pdg code
 108   return 113;
 109 }
 110
 111 Double_t AliGenEMlib::PtRho( const Double_t *px, const Double_t */*dummy*/ )
 112 {
 113 // Rho pT
 114   return MtScal(*px,2);
 115 }
 116
 117 Double_t AliGenEMlib::YRho( const Double_t *py, const Double_t */*dummy*/ )
 118 {
 119   return YFlat(*py);
 120
 121 }
 122
 123 //--------------------------------------------------------------------------
 124 //
 125 //                              Omega
 126 //
 127 //--------------------------------------------------------------------------
 128 Int_t AliGenEMlib::IpOmega(TRandom *)
 129 {
 130 // Return omega pdg code
 131   return 223;
 132 }
 133
 134 Double_t AliGenEMlib::PtOmega( const Double_t *px, const Double_t */*dummy*/ )
 135 {
 136 // Omega pT
 137   return MtScal(*px,3);
 138 }
 139
 140 Double_t AliGenEMlib::YOmega( const Double_t *py, const Double_t */*dummy*/ )
 141 {
 142   return YFlat(*py);
 143
 144 }
 145
 146 //--------------------------------------------------------------------------
 147 //
 148 //                              Etaprime
 149 //
 150 //--------------------------------------------------------------------------
 151 Int_t AliGenEMlib::IpEtaprime(TRandom *)
 152 {
 153 // Return etaprime pdg code
 154   return 331;
 155 }
 156
 157 Double_t AliGenEMlib::PtEtaprime( const Double_t *px, const Double_t */*dummy*/ )
 158 {
 159 // Eta pT
 160   return MtScal(*px,4);
 161 }
 162
 163 Double_t AliGenEMlib::YEtaprime( const Double_t *py, const Double_t */*dummy*/ )
 164 {
 165   return YFlat(*py);
 166
 167 }
 168
 169 //--------------------------------------------------------------------------
 170 //
 171 //                              Phi
 172 //
 173 //--------------------------------------------------------------------------
 174 Int_t AliGenEMlib::IpPhi(TRandom *)
 175 {
 176 // Return phi pdg code
 177   return 333;
 178 }
 179
 180 Double_t AliGenEMlib::PtPhi( const Double_t *px, const Double_t */*dummy*/ )
 181 {
 182 // Phi pT
 183   return MtScal(*px,5);
 184 }
 185
 186 Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ )
 187 {
 188   return YFlat(*py);
 189
 190 }
 191
 192 Double_t AliGenEMlib::YFlat(Double_t /*y*/)
 193 {
 194 //--------------------------------------------------------------------------
 195 //
 196 //                    flat rapidity distribution
 197 //
 198 //--------------------------------------------------------------------------
 199
 200   Double_t dNdy = 1.;
 201
 202   return dNdy;
 203
 204 }
 205
 206 //=============================================================
 207 //
 208 //                    Mt-scaling
 209 //
 210 //=============================================================
 211 //
 212  Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np)
 213 {
 214 // Function for the calculation of the Pt distribution for a
 215 // given particle np, from the pizero Pt distribution using
 216 // mt scaling.
 217
 218 // MASS   0=>PIZERO, 1=>ETA, 2=>RHO, 3=>OMEGA, 4=>ETAPRIME, 5=>PHI
 219
 220   const Double_t khm[6] = {0.13498, 0.54751, 0.7755, 0.78265, 0.95778, 1.01946};
 221
 222   Double_t scaledPt = sqrt(pt*pt + khm[np]*khm[np] - khm[0]*khm[0]);
 223   Double_t scaledYield = PtPizero(&scaledPt, (Double_t*) 0);
 224
 225   //     VALUE MESON/PI AT 5 GEV
 226
 227   Double_t normPt = 5.;
 228   Double_t scaledNormPt = sqrt(normPt*normPt + khm[np]*khm[np] - khm[0]*khm[0]);
 229   const Double_t kfmax[6]={1., 0.48, 1.0, 0.9, 0.25, 0.4};
 230
 231   Double_t norm = kfmax[np] * (PtPizero(&normPt, (Double_t*) 0) / PtPizero(&scaledNormPt, (Double_t*) 0));
 232
 233   return norm*(pt/scaledPt)*scaledYield;
 234 }
 235
 236 //==========================================================================
 237 //
 238 //                     Set Getters
 239 //
 240 //==========================================================================
 241
 242 typedef Double_t (*GenFunc) (const Double_t*,  const Double_t*);
 243
 244 typedef Int_t (*GenFuncIp) (TRandom *);
 245
 246 GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const
 247 {
 248 // Return pointer to pT parameterisation
 249    GenFunc func=0;
 250    TString sname(tname);
 251
 252    switch (param)
 253     {
 254     case kPizero:
 255       func=PtPizero;
 256       break;
 257     case kEta:
 258       func=PtEta;
 259       break;
 260     case kRho:
 261       func=PtRho;
 262       break;
 263     case kOmega:
 264       func=PtOmega;
 265       break;
 266     case kEtaprime:
 267       func=PtEtaprime;
 268       break;
 269     case kPhi:
 270       func=PtPhi;
 271       break;
 272
 273     default:
 274       func=0;
 275       printf("<AliGenEMlib::GetPt> unknown parametrisation\n");
 276     }
 277    return func;
 278 }
 279
 280 GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const
 281 {
 282 // Return pointer to y- parameterisation
 283    GenFunc func=0;
 284    TString sname(tname);
 285
 286    switch (param)
 287     {
 288     case kPizero:
 289          func=YPizero;
 290          break;
 291     case kEta:
 292          func=YEta;
 293          break;
 294     case kRho:
 295          func=YRho;
 296          break;
 297     case kOmega:
 298          func=YOmega;
 299          break;
 300     case kEtaprime:
 301          func=YEtaprime;
 302          break;
 303     case kPhi:
 304          func=YPhi;
 305          break;
 306
 307     default:
 308         func=0;
 309         printf("<AliGenEMlib::GetY> unknown parametrisation\n");
 310     }
 311     return func;
 312 }
 313
 314 GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const
 315 {
 316 // Return pointer to particle type parameterisation
 317    GenFuncIp func=0;
 318    TString sname(tname);
 319
 320    switch (param)
 321     {
 322     case kPizero:
 323          func=IpPizero;
 324          break;
 325     case kEta:
 326          func=IpEta;
 327          break;
 328     case kRho:
 329          func=IpRho;
 330          break;
 331     case kOmega:
 332          func=IpOmega;
 333          break;
 334     case kEtaprime:
 335          func=IpEtaprime;
 336          break;
 337     case kPhi:
 338          func=IpPhi;
 339          break;
 340
 341     default:
 342         func=0;
 343         printf("<AliGenEMlib::GetIp> unknown parametrisation\n");
 344     }
 345     return func;
 346 }
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358