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 <Riostream.h>
  30 #include "TMath.h"
  31 #include "TRandom.h"
  32 #include "TString.h"
  33 #include "AliGenEMlib.h"
  34
  35
  36 ClassImp(AliGenEMlib)
  37
  38 //Initializers for static members
  39 Int_t AliGenEMlib::fgSelectedPtParam=AliGenEMlib::kPizero7TeVpp;
  40 Int_t AliGenEMlib::fgSelectedCentrality=AliGenEMlib::kpp;
  41 Int_t AliGenEMlib::fgSelectedV2Systematic=AliGenEMlib::kNoV2Sys;
  42
  43 Double_t AliGenEMlib::CrossOverLc(const double a, const double b, const double x){
  44   if(x<b-a/2) return 1.0;
  45   else if(x>b+a/2) return 0.0;
  46   else return cos(((x-b)/a+0.5)*TMath::Pi())/2+0.5;
  47 }
  48 Double_t AliGenEMlib::CrossOverRc(const double a, const double b, const double x){
  49   return 1-CrossOverLc(a,b,x);
  50 }
  51
  52 const Double_t AliGenEMlib::fgkV2param[16][15] = {
  53   // charged pion                                                                                                                        cent, based on
  54   {  0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // pp no V2
  55   ,{ 6.551541e-02, 1.438274e+00, 4.626379e-02, 2.512477e+00, 1.371824e+00, 2.964543e-02, 4.630670e+00, 4.228889e+00, 6.037970e-02, 1.425269e-03, 1.144124e+00, 0, 1, 9.154016e-04, 1.288285e+00 }  // 0-5,  Francesco
  56   ,{ 1.171360e-01, 1.333046e+00, 4.536752e-02, 3.046448e+00, 3.903714e+00, 4.407124e-02, 9.122534e-01, 4.834519e+00, 1.186237e-01, 2.179274e-03, 8.968478e-01, 0, 1, 1.501201e-03, 9.902785e-01 }  // 5-10, Francesco
  57   ,{ 1.748423e-01, 1.285211e+00, 4.219624e-02, 4.019148e+00, 4.255047e+00, 7.956751e-03, 1.184731e-01,-9.211391e+00, 5.768716e-01, 3.127110e-03, 6.808650e-01, 0, 1, 2.786807e-03, 6.159338e-01 }  // 10-20,Francesco
  58   ,{ 2.152937e-01, 1.405391e+00, 5.037925e-02, 3.214458e+00, 3.991894e+00, 3.655882e-02, 1.968766e-01,-1.637650e+01, 7.023397e+00, 4.573453e-03, 6.031381e-01, 0, 1, 3.564348e-03, 5.748053e-01 }  // 20-30,Francesco
  59   ,{ 2.409800e-01, 1.476557e+00, 5.759362e-02, 3.339713e+00, 3.642386e+00,-1.544366e-02, 1.098611e-01,-1.373154e+01, 1.471955e+00, 5.200180e-03, 6.315474e-01, 0, 1, 3.776112e-03, 6.298605e-01 }  // 30-40,Francesco
  60   ,{ 2.495087e-01, 1.543711e+00, 6.217817e-02, 3.517101e+00, 4.558221e+00, 6.021316e-02, 1.486822e-01,-5.769155e+00, 5.576843e-01, 5.348029e-03, 7.255976e-01, 0, 1, 3.531350e-03, 7.661694e-01 }  // 40-50,Francesco
  61   ,{ 2.166449e-01, 1.931014e+00, 8.195656e-02, 2.226742e+00, 3.106472e+00, 1.058786e-01, 8.558786e-01, 4.006680e+00, 2.476313e-01, 5.137623e-03, 9.104401e-01, 0, 1, 2.477450e-03, 1.109649e+00 }  // 50-60,Francesco
  62   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-10
  63   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 20-40
  64   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 40-60
  65   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 60-80
  66   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-20
  67   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-40
  68   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 20-80
  69   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 40-80
  70 };
  71
  72 const Double_t AliGenEMlib::fgkRawPtOfV2Param[16][10] = {
  73   {  0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // pp no V2
  74   ,{ 2.181446e+08, 9.412925e-01, 1.158774e-01, 3.020303e+01, 6.790828e+00, 9.999996e+01, 2.616827e+00, 3.980492e+00, 1.225169e+07, 5.575243e+00 } // 0-5
  75   ,{ 3.006215e+08, 9.511881e-01, 1.192788e-01, 2.981931e+01, 5.068175e+01, 9.999993e+01, 2.650635e+00, 4.073982e+00, 2.508045e+07, 5.621039e+00 } // 5-10
  76   ,{ 1.643438e+09, 9.604242e-01, 1.218512e-01, 2.912684e+01, 1.164242e+00, 9.999709e+01, 2.662326e+00, 4.027795e+00, 7.020810e+07, 5.696860e+00 } // 10-20
  77   ,{ 8.109985e+08, 9.421935e-01, 1.328020e-01, 2.655910e+01, 1.053677e+00, 9.999812e+01, 2.722949e+00, 3.964547e+00, 6.104096e+07, 5.694703e+00 } // 20-30
  78   ,{ 5.219789e+08, 9.417339e-01, 1.417541e-01, 2.518080e+01, 7.430803e-02, 9.303295e+01, 2.780227e+00, 3.909570e+00, 4.723116e+07, 5.778375e+00 } // 30-40
  79   ,{ 2.547159e+08, 9.481459e-01, 2.364858e-01, 1.689288e+01, 3.858883e+00, 6.352619e+00, 2.742270e+00, 3.855226e+00, 3.120535e+07, 5.878677e+00 } // 40-50
  80   ,{ 9.396097e+07, 9.304491e-01, 3.244940e-01, 1.291696e+01, 2.854367e+00, 6.325908e+00, 2.828258e+00, 4.133699e+00, 1.302739e+07, 5.977896e+00 } // 50-60
  81   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-10
  82   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 20-40
  83   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 40-60
  84   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 60-80
  85   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-20
  86   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-40
  87   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 20-80
  88   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 40-80
  89 };
  90
  91 const Double_t AliGenEMlib::fgkThermPtParam[16][2] = {
  92   {  0.0000000000, 0.0000000000 } // pp no V2
  93   ,{ 0.0000000000, 0.0000000000 } // 0-5
  94   ,{ 0.0000000000, 0.0000000000 } // 5-10
  95   ,{ 2.581823e+01, 3.187900e+00 } // 10-20 //from: https://aliceinfo.cern.ch/Notes/node/249
  96   ,{ 0.0000000000, 0.0000000000 } // 20-30
  97   ,{ 0.0000000000, 0.0000000000 } // 30-40
  98   ,{ 0.0000000000, 0.0000000000 } // 40-50
  99   ,{ 0.0000000000, 0.0000000000 } // 50-60
 100   ,{ 7.177551e+02, 4.946179e+00 } // 0-10  //from: https://aliceinfo.cern.ch/Notes/node/249
 101   ,{ 2.328661e+00, 2.635257e+00 } // 20-40 //from: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
 102   ,{ 0.0000000000, 0.0000000000 } // 40-60
 103   ,{ 0.0000000000, 0.0000000000 } // 60-80
 104   ,{ 1.919280e+01, 2.946472e+00 } // 0-20  //from: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
 105   ,{ 0.0000000000, 0.0000000000 } // 0-40
 106   ,{ 0.0000000000, 0.0000000000 } // 20-80
 107   ,{ 0.0000000000, 0.0000000000 } // 40-80
 108 };
 109
 110 // MASS   0=>PIZERO, 1=>ETA, 2=>RHO, 3=>OMEGA, 4=>ETAPRIME, 5=>PHI, 6=>JPSI
 111 const Double_t AliGenEMlib::fgkHM[8] = {0.13498, 0.54751, 0.7755, 0.78265, 0.95778, 1.01946, 3.0969, 0.0};
 112
 113 const Double_t AliGenEMlib::fgkMtFactor[2][8] = {
 114   // {1.0, 0.5, 1.0, 0.9, 0.4, 0.23, 0.054},  // factor for pp from arXiv:1110.3929
 115   // {1.0, 0.55, 1.0, 0.9, 0.4, 0.25, 0.004}    // factor for PbPb from arXiv:1110.3929
 116   //{1., 0.48, 1.0, 0.9, 0.25, 0.4}, (old values)
 117   //{1., 0.48, 1.0, 0.9, 0.4, 0.25}, (nlo values)
 118   //{1., 0.48, 1.0, 0.8, 0.4, 0.2, 0.06} (combination of nlo and LHC measurements)
 119   //https://aliceinfo.cern.ch/Figure/node/2634
 120   //https://aliceinfo.cern.ch/Figure/node/2788
 121   //https://aliceinfo.cern.ch/Figure/node/4403
 122   //J/Psi PbPb from Comparison with Julian Books J/Psi -> e+e-, might be contradicting with https://aliceinfo.cern.ch/Figure/node/3457
 123   //https://aliceinfo.cern.ch/Notes/node/87
 124   //best guess:
 125   {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0.004, 0.}, //pp
 126   {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0.0195, 0.}  //PbPb
 127 };
 128
 129 //==========================================================================
 130 //
 131 //              Definition of Particle Distributions
 132 //
 133 //==========================================================================
 134
 135 //--------------------------------------------------------------------------
 136 //
 137 //                              General functions
 138 //
 139 //--------------------------------------------------------------------------
 140 Double_t AliGenEMlib::PtModifiedHagedornThermal(const Double_t pt,
 141                                                 const Double_t c,
 142                                                 const Double_t p0,
 143                                                 const Double_t p1,
 144                                                 const Double_t n,
 145                                                 const Double_t cT,
 146                                                 const Double_t T)
 147 {
 148   // Modified Hagedorn Thermal fit to Picharged for PbPb:
 149   Double_t invYield;
 150   invYield = c/TMath::Power(p0+pt/p1,n) + cT*exp(-1.0*pt/T);
 151
 152   return invYield*(2*TMath::Pi()*pt);
 153 }
 154
 155
 156
 157 Double_t AliGenEMlib::PtModifiedHagedornExp(const Double_t pt,
 158                                             const Double_t c,
 159                                             const Double_t p1,
 160                                             const Double_t p2,
 161                                             const Double_t p0,
 162                                             const Double_t n)
 163 {
 164   // Modified Hagedorn exponentiel fit to Pizero for PbPb:
 165   Double_t invYield;
 166   invYield = c*TMath::Power(exp(-1*(p1*pt-p2*pt*pt))+pt/p0,-n);
 167
 168   return invYield*(2*TMath::Pi()*pt);
 169 }
 170
 171
 172 Double_t AliGenEMlib::PtModifiedHagedornExp2(const Double_t pt,
 173                                              const Double_t c,
 174                                              const Double_t a,
 175                                              const Double_t b,
 176                                              const Double_t p0,
 177                                              const Double_t p1,
 178                                              const Double_t d,
 179                                              const Double_t n)
 180 {
 181   // Modified Hagedorn exponential fit to charged pions for pPb:
 182   Double_t invYield;
 183   invYield = c*TMath::Power(exp(-a*pt-b*pt*pt)+pt/p0+TMath::Power(pt/p1,d),-n);
 184
 185   return invYield*(2*TMath::Pi()*pt);
 186 }
 187
 188 Double_t AliGenEMlib::PtTsallis(const Double_t pt,
 189                                 const Double_t m,
 190                                 const Double_t c,
 191                                 const Double_t T,
 192                                 const Double_t n)
 193 {
 194   // Tsallis fit to Pizero for pp:
 195   Double_t mt;
 196   Double_t invYield;
 197
 198   mt = sqrt(m*m + pt*pt);
 199   invYield = c*((n-1.)*(n-2.))/(n*T*(n*T+m*(n-2.)))*pow(1.+(mt-m)/(n*T),-n);
 200
 201   return invYield*(2*TMath::Pi()*pt);
 202 }
 203
 204 // Exponential
 205 Double_t AliGenEMlib::PtExponential(const Double_t *px, const Double_t *c){
 206   const double &pt=px[0];
 207   Double_t invYield = c[0]*exp(-pt*c[1]);
 208
 209   return invYield*(2*TMath::Pi()*pt);
 210 }
 211
 212 // Hagedorn with additional Powerlaw
 213 Double_t AliGenEMlib::PtModifiedHagedornPowerlaw(const Double_t *px, const Double_t *c){
 214   double pt=px[0]+0.0001;
 215   Double_t invYield = c[0]*pow(c[1]+pt*c[2],-c[3])*CrossOverLc(c[5],c[4],pt)+CrossOverRc(c[7],c[6],pt)*c[8]*pow(pt,-c[9]);
 216
 217   return invYield*(2*TMath::Pi()*pt);
 218 }
 219
 220 Double_t AliGenEMlib::IntegratedKrollWada(Double_t mh){
 221   if(mh<0.003) return 0;
 222   const double me=0.000511;
 223   return 2*log(mh/me/exp(7.0/4.0))/411.0/TMath::Pi();
 224 }
 225
 226 //--------------------------------------------------------------------------
 227 //
 228 //                             PromptRealGamma
 229 //
 230 //--------------------------------------------------------------------------
 231 Int_t AliGenEMlib::IpPromptRealGamma(TRandom *)
 232 {
 233   return 221000;
 234 }
 235
 236 Double_t AliGenEMlib::PtPromptRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 237 {
 238   //if(*px<0.001) return 0;
 239   const static Double_t promptGammaPtParam[10] = { 7.019259e-02, 6.771695e-01, 8.249346e-01, 5.720419e+00, 1.848869e+01, 2.629075e+01, 1.061126e+01, 3.699205e+01, 5.253572e-02, 5.167275e+00 };
 240   //{ 5.449971e-02, 3.843241e-01, 9.469766e-01, 4.993039e+00, 5.342451e+00, 4.457944e+00, 5.555146e+00, 4.458580e+00, 6.035177e-02, 5.102109e+00 };
 241
 242   return PtModifiedHagedornPowerlaw(px,promptGammaPtParam)*GetTAA(fgSelectedCentrality);
 243 }
 244
 245 Double_t AliGenEMlib::YPromptRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 246 {
 247   return YFlat(*px);
 248 }
 249
 250 Double_t AliGenEMlib::V2PromptRealGamma( const Double_t */*px*/, const Double_t */*dummy*/ )
 251 {
 252   return 0.0;
 253 }
 254
 255 //--------------------------------------------------------------------------
 256 //
 257 //                             PromptVirtGamma
 258 //
 259 //--------------------------------------------------------------------------
 260 Int_t AliGenEMlib::IpPromptVirtGamma(TRandom *)
 261 {
 262   return 223000;
 263 }
 264
 265 Double_t AliGenEMlib::PtPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 266 {
 267   return IntegratedKrollWada(*px)*PtPromptRealGamma(px,px);
 268 }
 269
 270 Double_t AliGenEMlib::YPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 271 {
 272   return YFlat(*px);
 273 }
 274
 275 Double_t AliGenEMlib::V2PromptVirtGamma( const Double_t */*px*/, const Double_t */*dummy*/ )
 276 {
 277   return 0.0;
 278 }
 279
 280 //--------------------------------------------------------------------------
 281 //
 282 //                             ThermRealGamma
 283 //
 284 //--------------------------------------------------------------------------
 285 Int_t AliGenEMlib::IpThermRealGamma(TRandom *)
 286 {
 287   return 222000;
 288 }
 289
 290 Double_t AliGenEMlib::PtThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 291 {
 292   return PtExponential(px,fgkThermPtParam[fgSelectedCentrality]);
 293 }
 294
 295 Double_t AliGenEMlib::YThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 296 {
 297   return YFlat(*px);
 298 }
 299
 300 Double_t AliGenEMlib::V2ThermRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 301 {
 302   return KEtScal(*px,8);
 303 }
 304
 305 //--------------------------------------------------------------------------
 306 //
 307 //                             ThermVirtGamma
 308 //
 309 //--------------------------------------------------------------------------
 310 Int_t AliGenEMlib::IpThermVirtGamma(TRandom *)
 311 {
 312   return 224000;
 313 }
 314
 315 Double_t AliGenEMlib::PtThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 316 {
 317   return IntegratedKrollWada(*px)*PtThermRealGamma(px,px);
 318 }
 319
 320 Double_t AliGenEMlib::YThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 321 {
 322   return YFlat(*px);
 323 }
 324
 325 Double_t AliGenEMlib::V2ThermVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 326 {
 327   return KEtScal(*px,8);
 328 }
 329
 330 //--------------------------------------------------------------------------
 331 //
 332 //                              Pizero
 333 //
 334 //--------------------------------------------------------------------------
 335 Int_t AliGenEMlib::IpPizero(TRandom *)
 336 {
 337   // Return pizero pdg code
 338   return 111;
 339 }
 340
 341 Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
 342 {
 343   // double pigammacorr=2.385389e-01*log(*px+0.001)+1.557687e+00;
 344   // pigammacorr*=9.513666e-03*log(*px+0.001)+9.509347e-01;
 345   // return pigammacorr*PtPromptRealGamma(px,px);  //misuse pion for direct gammas
 346
 347   // fit functions and corresponding parameter of Pizero pT for pp @ 2.76 TeV and @ 7 TeV and for PbPb @ 2.76 TeV
 348
 349   Double_t km=0.;
 350   Double_t kc=0.;
 351   Double_t kn=0.;
 352   Double_t kcT=0.;
 353   Double_t kT=0.;
 354   Double_t kp0=0.;
 355   Double_t kp1=0.;
 356   Double_t kp2=0.;
 357   Double_t ka=0.;
 358   Double_t kb=0.;
 359   Double_t kd=0.;
 360
 361   switch(fgSelectedPtParam|fgSelectedCentrality) {
 362     // fit to pi charged v1
 363     // charged pion from ToF, unidentified hadrons scaled with pion from TPC
 364     // for Pb-Pb @ 2.76 TeV
 365   case kPichargedPbPb|k0005:
 366     kc=1347.5; kp0=0.9393; kp1=2.254; kn=11.294; kcT=0.002537; kT=2.414;
 367     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 368     break;
 369   case kPichargedPbPb|k0510:
 370     kc=1256.1; kp0=0.9545; kp1=2.248; kn=11.291; kcT=0.002662; kT=2.326;
 371     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 372     break;
 373   case kPichargedPbPb|k2030:
 374     kc=7421.6; kp0=1.2059; kp1=1.520; kn=10.220; kcT=0.002150; kT=2.196;
 375     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 376     break;
 377   case kPichargedPbPb|k3040:
 378     kc=1183.2; kp0=1.0478; kp1=1.623; kn=9.8073; kcT=0.00198333; kT=2.073;
 379     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 380     break;
 381     // the following is what went into the Pb-Pb preliminary approval (0-10%)
 382   case kPichargedPbPb|k0010:
 383     kc=1296.0; kp0=0.968; kp1=2.567; kn=12.27; kcT=0.004219; kT=2.207;
 384     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 385     break;
 386   case kPichargedPbPb|k1020:
 387     kc=986.0; kp0=0.9752; kp1=2.376; kn=11.62; kcT=0.003116; kT=2.213;
 388     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 389     break;
 390   case kPichargedPbPb|k2040:
 391     kc=17337.0; kp0=1.337; kp1=1.507; kn=10.629; kcT=0.00184; kT=2.234;
 392     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 393     break;
 394   case kPichargedPbPb|k4050:
 395     kc=6220.0; kp0=1.322; kp1=1.224; kn=9.378; kcT=0.000595; kT=2.383;
 396     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 397     break;
 398   case kPichargedPbPb|k5060:
 399     kc=2319.0; kp0=1.267; kp1=1.188; kn=9.044; kcT=0.000437; kT=2.276;
 400     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 401     break;
 402   case kPichargedPbPb|k4060:
 403     kc=4724.0; kp0=1.319; kp1=1.195; kn=9.255; kcT=0.000511; kT=2.344;
 404     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 405     break;
 406   case kPichargedPbPb|k6080:
 407     kc=2842.0; kp0=1.465; kp1=0.8324; kn=8.167; kcT=0.0001049; kT=2.29;
 408     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 409     break;
 410
 411
 412     // fit to pizero from conversion analysis
 413     // for PbPb @ 2.76 TeV
 414     // Pi0 spectra --> not final results
 415   case kPizeroPbPb|k0005:
 416        kc=1952.832; kp1=0.264; kp2=0.069; kp0=1.206; kn=9.732;
 417        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 418        break;
 419   case kPizeroPbPb|k0010:
 420        kc=1810.029; kp1=0.291; kp2=0.059; kp0=1.170; kn=9.447;
 421        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 422        break;
 423   case kPizeroPbPb|k0020:
 424        kc=856.241; kp1=-0.409; kp2=-0.127; kp0=1.219; kn=9.030;
 425        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 426        break;
 427   case kPizeroPbPb|k1020:
 428        kc=509.781; kp1=-0.784; kp2=-0.120; kp0=0.931; kn=7.299;
 429        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 430        break;
 431   case kPizeroPbPb|k2040:
 432        kc=541.049; kp1=0.542; kp2=-0.069; kp0=0.972; kn=7.866;
 433        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 434        break;
 435   case kPizeroPbPb|k2080:
 436        kc=222.577; kp1=0.634; kp2=0.009; kp0=0.915; kn=7.431;
 437        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 438        break;
 439   case kPizeroPbPb|k4080:
 440        kc=120.153; kp1=0.7; kp2=-0.14; kp0=0.835; kn=6.980;
 441        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 442        break;
 443   case kPizeroPbPb|k0040:
 444        kc=560.532; kp1=0.548; kp2=-0.048; kp0=1.055; kn=8.132;
 445        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 446        break;
 447
 448
 449     // fit to charged pions for p-Pb @ 5.02TeV
 450   case kPichargedPPb:
 451        kc=235.5; ka=0.6903; kb=0.06864; kp0=2.289; kp1=0.5872; kd=0.6474; kn=7.842;
 452        return PtModifiedHagedornExp2(*px,kc,ka,kb,kp0,kp1,kd,kn);
 453        break;
 454
 455
 456     // Tsallis fit to final pizero (PHOS+PCM) -> used for publication
 457     // for pp @ 7 TeV
 458   case kPizero7TeVpp:
 459   case kPizeroEta7TeVpp:
 460     km=0.13498; kc=28.01; kT=0.139; kn=6.875;
 461     return PtTsallis(*px,km,kc,kT,kn);
 462     break;
 463   case kPizero7TeVpplow:
 464   case kPizeroEta7TeVpplow:
 465     km=0.13498; kc=23.84; kT=0.147; kn=7.025;
 466     return PtTsallis(*px,km,kc,kT,kn);
 467     break;
 468   case kPizero7TeVpphigh:
 469   case kPizeroEta7TeVpphigh:
 470     km=0.13498; kc=32.47; kT=0.132; kn=6.749;
 471     return PtTsallis(*px,km,kc,kT,kn);
 472     break;
 473     // Tsallis fit to pizero: preliminary result from PCM and PHOS (QM'11)
 474     // for pp @ 2.76 TeV
 475   case kPizero2760GeVpp:
 476   case kPizeroEta2760GeVpp:
 477     km = 0.13498; kc = 19.75; kT = 0.130; kn = 7.051;
 478     return PtTsallis(*px,km,kc,kT,kn);
 479     break;
 480   case kPizero2760GeVpplow:
 481   case kPizeroEta2760GeVpplow:
 482     km = 0.13498; kc = 16.12; kT = 0.142; kn = 7.327;
 483     return PtTsallis(*px,km,kc,kT,kn);
 484     break;
 485   case kPizero2760GeVpphigh:
 486   case kPizeroEta2760GeVpphigh:
 487     km = 0.13498; kc = 25.18; kT = 0.118; kn = 6.782;
 488     return PtTsallis(*px,km,kc,kT,kn);
 489     break;
 490
 491   default:
 492     return NULL;
 493   }
 494
 495 }
 496
 497 Double_t AliGenEMlib::YPizero( const Double_t *py, const Double_t */*dummy*/ )
 498 {
 499   return YFlat(*py);
 500
 501 }
 502
 503 Double_t AliGenEMlib::V2Pizero( const Double_t *px, const Double_t */*dummy*/ )
 504 {
 505   double n1,n2,v1,v2;
 506   switch(fgSelectedCentrality) {
 507   case k0010:
 508     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
 509     v1=V2Param(px,fgkV2param[k0005]);
 510     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
 511     v2=V2Param(px,fgkV2param[k0510]);
 512     return (n1*v1+n2*v2)/(n1+n2);
 513     break;
 514   case k2040:
 515     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k2030]);
 516     v1=V2Param(px,fgkV2param[k2030]);
 517     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k3040]);
 518     v2=V2Param(px,fgkV2param[k3040]);
 519     return (n1*v1+n2*v2)/(n1+n2);
 520     break;
 521
 522   default:
 523     return V2Param(px,fgkV2param[fgSelectedCentrality]);
 524   }
 525 }
 526
 527 //--------------------------------------------------------------------------
 528 //
 529 //                              Eta
 530 //
 531 //--------------------------------------------------------------------------
 532 Int_t AliGenEMlib::IpEta(TRandom *)
 533 {
 534   // Return eta pdg code
 535   return 221;
 536 }
 537
 538 Double_t AliGenEMlib::PtEta( const Double_t *px, const Double_t */*dummy*/ )
 539 {
 540
 541   // fit functions and corresponding parameter of Eta pT for pp @ 2.76 TeV and @ 7 TeV
 542   // and mtscaled pT
 543
 544   Double_t km = 0.;
 545   Double_t kc = 0.;
 546   Double_t kT = 0.;
 547   Double_t kn = 0.;
 548
 549   switch(fgSelectedPtParam){
 550     // Tsallis fit to final eta (PHOS+PCM) -> used for final publication
 551     // for pp @ 7 TeV
 552   case kPizeroEta7TeVpp:
 553     km = 0.547853; kc = 2.496; kT = 0.229; kn = 6.985;
 554     return PtTsallis(*px,km,kc,kT,kn);
 555     break;
 556   case kPizeroEta7TeVpplow:
 557     km = 0.547853; kc = 1.970; kT = 0.253; kn = 7.591;
 558     return PtTsallis(*px,km,kc,kT,kn);
 559     break;
 560   case kPizeroEta7TeVpphigh:
 561     km = 0.547853; kc = 3.060; kT = 0.212; kn = 6.578;
 562     return PtTsallis(*px,km,kc,kT,kn);
 563     break;
 564     // Tsallis fit to preliminary eta (QM'11)
 565     // for pp @ 2.76 TeV
 566   case kPizeroEta2760GeVpp:
 567     km = 0.547853; kc = 1.971; kT = 0.188; kn = 6.308;
 568     return PtTsallis(*px,km,kc,kT,kn);
 569   case kPizeroEta2760GeVpplow:
 570     km = 0.547853; kc = 1.228; kT = 0.220; kn = 7.030;
 571     return PtTsallis(*px,km,kc,kT,kn);
 572     break;
 573   case kPizeroEta2760GeVpphigh:
 574     km = 0.547853; kc = 2.802; kT = 0.164; kn = 5.815;
 575     return PtTsallis(*px,km,kc,kT,kn);
 576     break;
 577
 578   default:
 579   return MtScal(*px,1);
 580     break;
 581
 582   }
 583
 584 }
 585
 586 Double_t AliGenEMlib::YEta( const Double_t *py, const Double_t */*dummy*/ )
 587 {
 588   return YFlat(*py);
 589 }
 590
 591 Double_t AliGenEMlib::V2Eta( const Double_t *px, const Double_t */*dummy*/ )
 592 {
 593   return KEtScal(*px,1); //V2Param(px,fgkV2param[1][fgSelectedV2Param]);
 594 }
 595
 596 //--------------------------------------------------------------------------
 597 //
 598 //                              Rho
 599 //
 600 //--------------------------------------------------------------------------
 601 Int_t AliGenEMlib::IpRho(TRandom *)
 602 {
 603   // Return rho pdg code
 604   return 113;
 605 }
 606
 607 Double_t AliGenEMlib::PtRho( const Double_t *px, const Double_t */*dummy*/ )
 608 {
 609   // Rho pT
 610   return MtScal(*px,2);
 611 }
 612
 613 Double_t AliGenEMlib::YRho( const Double_t *py, const Double_t */*dummy*/ )
 614 {
 615   return YFlat(*py);
 616 }
 617
 618 Double_t AliGenEMlib::V2Rho( const Double_t *px, const Double_t */*dummy*/ )
 619 {
 620   return KEtScal(*px,2);
 621 }
 622
 623 //--------------------------------------------------------------------------
 624 //
 625 //                              Omega
 626 //
 627 //--------------------------------------------------------------------------
 628 Int_t AliGenEMlib::IpOmega(TRandom *)
 629 {
 630   // Return omega pdg code
 631   return 223;
 632 }
 633
 634 Double_t AliGenEMlib::PtOmega( const Double_t *px, const Double_t */*dummy*/ )
 635 {
 636   // Omega pT
 637   return MtScal(*px,3);
 638 }
 639
 640 Double_t AliGenEMlib::YOmega( const Double_t *py, const Double_t */*dummy*/ )
 641 {
 642   return YFlat(*py);
 643 }
 644
 645 Double_t AliGenEMlib::V2Omega( const Double_t *px, const Double_t */*dummy*/ )
 646 {
 647   return KEtScal(*px,3);
 648 }
 649
 650
 651 //--------------------------------------------------------------------------
 652 //
 653 //                              Etaprime
 654 //
 655 //--------------------------------------------------------------------------
 656 Int_t AliGenEMlib::IpEtaprime(TRandom *)
 657 {
 658   // Return etaprime pdg code
 659   return 331;
 660 }
 661
 662 Double_t AliGenEMlib::PtEtaprime( const Double_t *px, const Double_t */*dummy*/ )
 663 {
 664   // Eta pT
 665   return MtScal(*px,4);
 666 }
 667
 668 Double_t AliGenEMlib::YEtaprime( const Double_t *py, const Double_t */*dummy*/ )
 669 {
 670   return YFlat(*py);
 671
 672 }
 673
 674 Double_t AliGenEMlib::V2Etaprime( const Double_t *px, const Double_t */*dummy*/ )
 675 {
 676   return KEtScal(*px,4);
 677 }
 678
 679 //--------------------------------------------------------------------------
 680 //
 681 //                              Phi
 682 //
 683 //--------------------------------------------------------------------------
 684 Int_t AliGenEMlib::IpPhi(TRandom *)
 685 {
 686   // Return phi pdg code
 687   return 333;
 688 }
 689
 690 Double_t AliGenEMlib::PtPhi( const Double_t *px, const Double_t */*dummy*/ )
 691 {
 692   // Phi pT
 693   return MtScal(*px,5);
 694 }
 695
 696 Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ )
 697 {
 698   return YFlat(*py);
 699 }
 700
 701 Double_t AliGenEMlib::V2Phi( const Double_t *px, const Double_t */*dummy*/ )
 702 {
 703   return KEtScal(*px,5);
 704 }
 705
 706 //--------------------------------------------------------------------------
 707 //
 708 //                              Jpsi
 709 //
 710 //--------------------------------------------------------------------------
 711 Int_t AliGenEMlib::IpJpsi(TRandom *)
 712 {
 713   // Return phi pdg code
 714   return 443;
 715 }
 716
 717 Double_t AliGenEMlib::PtJpsi( const Double_t *px, const Double_t */*dummy*/ )
 718 {
 719   // Jpsi pT
 720   return MtScal(*px,6);
 721 }
 722
 723 Double_t AliGenEMlib::YJpsi( const Double_t *py, const Double_t */*dummy*/ )
 724 {
 725   return YFlat(*py);
 726 }
 727
 728 Double_t AliGenEMlib::V2Jpsi( const Double_t *px, const Double_t */*dummy*/ )
 729 {
 730   const int oldSys=fgSelectedV2Systematic;
 731   fgSelectedV2Systematic=kNoV2Sys;
 732   double ret=0;
 733
 734   switch(oldSys){
 735   case kLoV2Sys: ret=0; break;
 736   case kNoV2Sys: ret=KEtScal(*px,6)/2; break;
 737   case kUpV2Sys: ret=KEtScal(*px,6); break;
 738   }
 739
 740   fgSelectedV2Systematic=oldSys;
 741   return ret;
 742 }
 743
 744 Double_t AliGenEMlib::YFlat(Double_t /*y*/)
 745 {
 746   //--------------------------------------------------------------------------
 747   //
 748   //                    flat rapidity distribution
 749   //
 750   //--------------------------------------------------------------------------
 751
 752   Double_t dNdy = 1.;
 753
 754   return dNdy;
 755
 756 }
 757
 758 //=============================================================
 759 //
 760 //                    Mt-scaling
 761 //
 762 //=============================================================
 763 //
 764 Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np)
 765 {
 766   // Function for the calculation of the Pt distribution for a
 767   // given particle np, from the pizero Pt distribution using
 768   // mt scaling.
 769
 770   Double_t scaledPt = sqrt(pt*pt + fgkHM[np]*fgkHM[np] - fgkHM[0]*fgkHM[0]);
 771   Double_t scaledYield = PtPizero(&scaledPt, (Double_t*) 0);
 772
 773   //     VALUE MESON/PI AT 5 GeV/c
 774   Double_t NormPt = 5.;
 775   Double_t scaledNormPt = sqrt(NormPt*NormPt + fgkHM[np]*fgkHM[np] - fgkHM[0]*fgkHM[0]);
 776
 777   Double_t norm = fgkMtFactor[int(bool(fgSelectedCentrality))][np] * (PtPizero(&NormPt, (Double_t*) 0) / PtPizero(&scaledNormPt, (Double_t*) 0));
 778
 779   return norm*(pt/scaledPt)*scaledYield;
 780 }
 781
 782 Double_t AliGenEMlib::KEtScal(const Double_t pt, Int_t np)
 783 {
 784   const int nq=2; //number of quarks for particle np, here always 2
 785   Double_t scaledPt = sqrt(pow(2.0/nq*(sqrt(pt*pt+fgkHM[np]*fgkHM[np])-fgkHM[np])+fgkHM[0],2)-fgkHM[0]*fgkHM[0]);
 786   // double val=V2Pizero(&scaledPt, (Double_t*) 0);
 787   // static const double syserr[12]={0., 0.09, 0.07, 0.06, 0.04, 0.04, 0.04, 0.05, 0., 0., 0., 0.}; //based on pi vs kaon
 788   // double sys=fgSelectedV2Systematic*min(fgkV2param[fgSelectedCentrality][0],fgkV2param[fgSelectedCentrality][8])*syserr[fgSelectedCentrality];
 789   // return TMath::Max(val+sys,0.0);
 790   return V2Pizero(&scaledPt, (Double_t*) 0);
 791 }
 792
 793 Double_t AliGenEMlib::V2Param(const Double_t *px, const Double_t *par)
 794 {
 795   // Very general parametrization of the v2
 796
 797   const double &pt=px[0];
 798   double val=CrossOverLc(par[4],par[3],pt)*(2*par[0]/(1+TMath::Exp(par[1]*(par[2]-pt)))-par[0])+CrossOverRc(par[4],par[3],pt)*((par[8]-par[5])/(1+TMath::Exp(par[6]*(pt-par[7])))+par[5]);
 799   double sys=fgSelectedV2Systematic*par[11+fgSelectedV2Systematic*2]*pow(pt,par[12+fgSelectedV2Systematic*2]);
 800   return TMath::Max(val+sys,0.0);
 801 }
 802
 803 Double_t AliGenEMlib::V2Flat(const Double_t */*px*/, const Double_t */*param*/)
 804 {
 805   // Flat v2
 806
 807   return 0.0;
 808 }
 809
 810 Double_t AliGenEMlib::GetTAA(Int_t cent){
 811   const static Double_t taa[16] = { 1.0,    // pp
 812                                     26.32,  // 0-5
 813                                     20.56,  // 5-10
 814                                     14.39,  // 10-20
 815                                     8.70,   // 20-30
 816                                     5.001,  // 30-40
 817                                     2.675,  // 40-50
 818                                     1.317,  // 50-60
 819                                     23.44,  // 0-10
 820                                     6.85,   // 20-40
 821                                     1.996,  // 40-60
 822                                     0.4174, // 60-80
 823                                     18.91,  // 0-20
 824                                     12.88,  // 0-40
 825                                     3.088,  // 20-80
 826                                     1.207}; // 40-80
 827   return taa[cent];
 828 }
 829
 830 //==========================================================================
 831 //
 832 //                     Set Getters
 833 //
 834 //==========================================================================
 835
 836 typedef Double_t (*GenFunc) (const Double_t*,  const Double_t*);
 837
 838 typedef Int_t (*GenFuncIp) (TRandom *);
 839
 840 GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const
 841 {
 842   // Return pointer to pT parameterisation
 843    GenFunc func=0;
 844    TString sname(tname);
 845
 846    switch (param)
 847     {
 848     case kPromptRealGamma:
 849       func=PtPromptRealGamma;
 850       break;
 851     case kPromptVirtGamma:
 852       func=PtPromptVirtGamma;
 853       break;
 854     case kThermRealGamma:
 855       func=PtThermRealGamma;
 856       break;
 857     case kThermVirtGamma:
 858       func=PtThermVirtGamma;
 859       break;
 860     case kPizero:
 861       func=PtPizero;
 862       break;
 863     case kEta:
 864       func=PtEta;
 865       break;
 866     case kRho:
 867       func=PtRho;
 868       break;
 869     case kOmega:
 870       func=PtOmega;
 871       break;
 872     case kEtaprime:
 873       func=PtEtaprime;
 874       break;
 875     case kPhi:
 876       func=PtPhi;
 877       break;
 878     case kJpsi:
 879       func=PtJpsi;
 880       break;
 881
 882     default:
 883       func=0;
 884       printf("<AliGenEMlib::GetPt> unknown parametrisation\n");
 885     }
 886    return func;
 887 }
 888
 889 GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const
 890 {
 891   // Return pointer to y- parameterisation
 892    GenFunc func=0;
 893    TString sname(tname);
 894
 895    switch (param)
 896     {
 897     case kPromptRealGamma:
 898       func=YPromptRealGamma;
 899       break;
 900     case kPromptVirtGamma:
 901       func=YPromptVirtGamma;
 902       break;
 903     case kThermRealGamma:
 904       func=YThermRealGamma;
 905       break;
 906     case kThermVirtGamma:
 907       func=YThermVirtGamma;
 908       break;
 909     case kPizero:
 910          func=YPizero;
 911          break;
 912     case kEta:
 913          func=YEta;
 914          break;
 915     case kRho:
 916          func=YRho;
 917          break;
 918     case kOmega:
 919          func=YOmega;
 920          break;
 921     case kEtaprime:
 922          func=YEtaprime;
 923          break;
 924     case kPhi:
 925          func=YPhi;
 926          break;
 927     case kJpsi:
 928       func=YJpsi;
 929       break;
 930
 931     default:
 932         func=0;
 933         printf("<AliGenEMlib::GetY> unknown parametrisation\n");
 934     }
 935     return func;
 936 }
 937
 938 GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const
 939 {
 940   // Return pointer to particle type parameterisation
 941    GenFuncIp func=0;
 942    TString sname(tname);
 943
 944    switch (param)
 945     {
 946     case kPromptRealGamma:
 947       func=IpPromptRealGamma;
 948       break;
 949     case kPromptVirtGamma:
 950       func=IpPromptVirtGamma;
 951       break;
 952     case kThermRealGamma:
 953       func=IpThermRealGamma;
 954       break;
 955     case kThermVirtGamma:
 956       func=IpThermVirtGamma;
 957       break;
 958     case kPizero:
 959          func=IpPizero;
 960          break;
 961     case kEta:
 962          func=IpEta;
 963          break;
 964     case kRho:
 965          func=IpRho;
 966          break;
 967     case kOmega:
 968          func=IpOmega;
 969          break;
 970     case kEtaprime:
 971          func=IpEtaprime;
 972          break;
 973     case kPhi:
 974          func=IpPhi;
 975          break;
 976     case kJpsi:
 977       func=IpJpsi;
 978       break;
 979
 980     default:
 981         func=0;
 982         printf("<AliGenEMlib::GetIp> unknown parametrisation\n");
 983     }
 984     return func;
 985 }
 986
 987 GenFunc AliGenEMlib::GetV2(Int_t param, const char * tname) const
 988 {
 989   // Return pointer to v2-parameterisation
 990   GenFunc func=0;
 991   TString sname(tname);
 992
 993   switch (param)
 994     {
 995     case kPromptRealGamma:
 996       func=V2PromptRealGamma;
 997       break;
 998     case kPromptVirtGamma:
 999       func=V2PromptVirtGamma;
1000       break;
1001     case kThermRealGamma:
1002       func=V2ThermRealGamma;
1003       break;
1004     case kThermVirtGamma:
1005       func=V2ThermVirtGamma;
1006       break;
1007     case kPizero:
1008       func=V2Pizero;
1009       break;
1010     case kEta:
1011       func=V2Eta;
1012       break;
1013     case kRho:
1014       func=V2Pizero;
1015       break;
1016     case kOmega:
1017       func=V2Pizero;
1018       break;
1019     case kEtaprime:
1020       func=V2Pizero;
1021       break;
1022     case kPhi:
1023       func=V2Pizero;
1024       break;
1025     case kJpsi:
1026       func=V2Jpsi;
1027       break;
1028
1029     default:
1030       func=0;
1031       printf("<AliGenEMlib::GetV2> unknown parametrisation\n");
1032     }
1033   return func;
1034 }
1035