PWGLF/SPECTRA/Nuclei/masses/AliAnalysisNucleiMass.cxx

   1 #include "AliAnalysisNucleiMass.h"
   2
   3 // ROOT includes
   4 #include <TMath.h>
   5 #include "TChain.h"
   6
   7 // AliRoot includes
   8 #include "AliInputEventHandler.h"
   9 #include "AliAODEvent.h"
  10 #include "AliESDEvent.h"
  11 #include "AliVEvent.h"
  12 #include "AliAODTrack.h"
  13 #include "AliAODPid.h"
  14 #include "AliCentrality.h"
  15 #include "TH2F.h"
  16 #include "TH2D.h"
  17 #include "TH1F.h"
  18 #include "TF1.h"
  19 #include "TF2.h"
  20 #include "TGraph.h"
  21 #include "TProfile.h"
  22 #include "AliESDtrackCuts.h"
  23 #include "AliAnalysisManager.h"
  24 #include "TFile.h"
  25
  26 ClassImp(AliAnalysisNucleiMass)
  27
  28 //_____________________________________________________________________________
  29 AliAnalysisNucleiMass::AliAnalysisNucleiMass():
  30   AliAnalysisTaskSE(),
  31   Centrality(),
  32   FilterBit(16),
  33   EtaLimit(),
  34   DCAxyCut(0.1),
  35   DCAzCut(1000.),
  36   NsigmaTpcCut(2.0),
  37   NminTpcCluster(0),
  38   iTrdCut(0),
  39   kSignalCheck(1),
  40   iMtof(1),
  41   kPvtxCorr(1),
  42   iBconf(0),
  43   kTOF(0),
  44   fAOD(NULL),
  45   fESD(NULL),
  46   fEvent(NULL),
  47   fPIDResponse(NULL)
  48 {
  49   Centrality[0]=0.0;
  50   Centrality[1]=100.0;
  51
  52   EtaLimit[0]=-99.0;
  53   EtaLimit[1]=99.0;
  54
  55   fList[0]=new TList();
  56   fList[0]->SetName("results");
  57
  58   fList[1]=new TList();
  59   fList[1]->SetName("results2");
  60 }
  61 //______________________________________________________________________________
  62 AliAnalysisNucleiMass::AliAnalysisNucleiMass(const char *name):
  63   AliAnalysisTaskSE(name),
  64   Centrality(),
  65   FilterBit(16),
  66   EtaLimit(),
  67   DCAxyCut(0.1),
  68   DCAzCut(1000.),
  69   NsigmaTpcCut(2.0),
  70   NminTpcCluster(0),
  71   iTrdCut(0),
  72   kSignalCheck(1),
  73   iMtof(1),
  74   kPvtxCorr(1),
  75   iBconf(0),
  76   kTOF(0),
  77   fAOD(NULL),
  78   fESD(NULL),
  79   fEvent(NULL),
  80   fPIDResponse(NULL)
  81 {
  82
  83   Centrality[0]=0.0;
  84   Centrality[1]=100.0;
  85
  86   EtaLimit[0]=-99.0;
  87   EtaLimit[1]=99.0;
  88
  89   fList[0]=new TList();
  90   DefineOutput(1, TList::Class());
  91   fList[0]->SetName("results");
  92
  93   fList[1]=new TList();
  94   DefineOutput(2, TList::Class());
  95   fList[1]->SetName("results2");
  96 }
  97 //_____________________________________________________________________________
  98 AliAnalysisNucleiMass::~AliAnalysisNucleiMass()
  99 {
 100   if(fList[0]) delete fList[0];
 101   if(fList[1]) delete fList[1];
 102 }
 103 //______________________________________________________________________________
 104 void AliAnalysisNucleiMass::UserCreateOutputObjects()
 105 {
 106   Char_t namePart[nPart][30];
 107   snprintf(namePart[0],30,"e");
 108   snprintf(namePart[1],30,"#mu");
 109   snprintf(namePart[2],30,"#pi");
 110   snprintf(namePart[3],30,"K");
 111   snprintf(namePart[4],30,"p");
 112   snprintf(namePart[5],30,"d");
 113   snprintf(namePart[6],30,"t");
 114   snprintf(namePart[7],30,"He3");
 115   snprintf(namePart[8],30,"He4");
 116
 117   Char_t name[nSpec][30];
 118   snprintf(name[0],20,"e^{+}");
 119   snprintf(name[1],20,"#mu^{+}");
 120   snprintf(name[2],20,"#pi^{+}");
 121   snprintf(name[3],20,"K^{+}");
 122   snprintf(name[4],20,"p");
 123   snprintf(name[5],20,"d");
 124   snprintf(name[6],20,"t");
 125   snprintf(name[7],20,"He3");
 126   snprintf(name[8],20,"He4");
 127   snprintf(name[9],20,"e^{-}");
 128   snprintf(name[10],20,"#mu^{-}");
 129   snprintf(name[11],20,"#pi^{-}");
 130   snprintf(name[12],20,"K^{-}");
 131   snprintf(name[13],20,"#bar{p}");
 132   snprintf(name[14],20,"#bar{d}");
 133   snprintf(name[15],20,"#bar{t}");
 134   snprintf(name[16],20,"#bar{He3}");
 135   snprintf(name[17],20,"#bar{He4}");
 136
 137   Double_t binP[nbin+1];
 138   for(Int_t i=0;i<nbin+1;i++) {
 139     binP[i]=0.4+0.1*i;
 140   }
 141
 142   Char_t name_nbin[nbin][200];
 143   for(Int_t j=0;j<nbin;j++) {
 144     snprintf(name_nbin[j],200,"%.1f<P<%.1f",binP[j],binP[j+1]);
 145   }
 146
 147   for(Int_t iB=0;iB<nBconf;iB++) {
 148
 149     htemp[iB] = new TH1F("htemp","htemp (avoid the problem with the empty list...);B field",20,-10,10);
 150
 151     hCentrality[iB][0] = new TH1F("hCentrality_Selected","Centrality (selected events);centrality(%)",20,0,100);
 152     hCentrality[iB][1] = new TH1F("hCentrality_Analyzed","Centrality (analyzed events);centrality (%)",20,0,100);
 153
 154     hZvertex[iB][0] = new TH1F("hZvertex_Selected","Vertex distribution of selected events;z vertex (cm)",240,-30,30);
 155     hZvertex[iB][1] = new TH1F("hZvertex_Analyzed","Vertex distribution of analyzed events;z vertex (cm)",240,-30,30);
 156
 157     hEta[iB] = new TH1F("hEta_Analyzed","|#eta| distribution after the track cuts;|#eta|",200,-1.0,1.0);
 158
 159     hPhi[iB] = new TH1F("hPhi_Analyzed","#phi distribution after the track cuts;#phi (rad.)",90,0,6.3);//Each TRD supermodule is divided for 5 (DeltaPhi(TRD)=0.35 theoretical)
 160
 161     Int_t hbins[2];
 162     if(kSignalCheck!=0) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=100; hbins[1]=90;} to reduce RAM consuming (toram)
 163     else {hbins[0]=1; hbins[1]=1;}
 164     fEtaPhi[iB] = new TH2F("fEtaPhi_Analyzed","#eta vs. #phi after the track cuts;|#eta|;#phi (rad.)",hbins[0],-1.0,1.0,hbins[1],0,6.3);
 165
 166     hNTpcCluster[iB] = new TH1F("hNTpcCluster","Number of the TPC clusters after the track cuts;n_{cl}^{TPC}",300,0,300);
 167
 168     hNTrdSlices[iB] = new TH1F("hNTrdSlices","Number of the TRD slices after the track cuts;n_{slices}^{TRD}",40,0,40);
 169
 170     if(kSignalCheck==1) {hbins[0]=500; hbins[1]=2000;}
 171     else if(kSignalCheck==0) {hbins[0]=1; hbins[1]=1;}
 172     else if(kSignalCheck==2) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=100; hbins[1]=500;} toram
 173     fdEdxVSp[iB][0] = new TH2F("fdEdxVSp_pos","dE/dx vs p (positive charge); p/|z| (GeV/c); dE/dx_{TPC} (a.u.)",hbins[0],0,5,hbins[1],0,1000);
 174     fdEdxVSp[iB][1] = new TH2F("fdEdxVSp_neg","dE/dx vs p (negative charge); p/|z| (GeV/c); dE/dx_{TPC} (a.u.)",hbins[0],0,5,hbins[1],0,1000);
 175
 176     Char_t name_hDeDxExp[nPart][200];
 177     Char_t title_hDeDxExp[nPart][200];
 178     for(Int_t i=0;i<nPart;i++) {
 179       snprintf(name_hDeDxExp[i],200,"hDeDxExp_%s",namePart[i]);
 180       snprintf(title_hDeDxExp[i],200,"Expected dE/dx of %s in the TPC;p/|z| (GeV/c);dE/dx_{TPC} (a.u.)",namePart[i]);
 181       hDeDxExp[iB][i] = new TProfile(name_hDeDxExp[i],title_hDeDxExp[i],1,0,5,0,1,"");//,500,0,5,0,1000,""); toram
 182     }
 183
 184     Char_t name_fNsigmaTpc[nPart][200];
 185     Char_t title_fNsigmaTpc[nPart][200];
 186     if(kSignalCheck==1) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=100; hbins[1]=100;} toram
 187     else {hbins[0]=1; hbins[1]=1;}
 188     for(Int_t i=0;i<nPart;i++) {
 189       snprintf(name_fNsigmaTpc[i],200,"NsigmaTpc_%s",namePart[i]);
 190       snprintf(title_fNsigmaTpc[i],200,"NsigmaTpc_%s;p_{TPC}/|z| (GeV/c);n_{#sigma_{TPC}}^{%s}",namePart[i],namePart[i]);
 191       fNsigmaTpc[iB][i] = new TH2F(name_fNsigmaTpc[i],title_fNsigmaTpc[i],hbins[0],0,5,hbins[1],-5,5);
 192     }
 193
 194     if(kSignalCheck>0) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=100; hbins[1]=100;} toram
 195     else if(kSignalCheck==0) {hbins[0]=1; hbins[1]=1;}
 196     Char_t name_fNsigmaTpc_kTOF[nSpec][200];
 197     Char_t title_fNsigmaTpc_kTOF[nSpec][200];
 198     for(Int_t i=0;i<nSpec;i++) {
 199       snprintf(name_fNsigmaTpc_kTOF[i],200,"NsigmaTpc_%s_kTOF",name[i]);
 200       snprintf(title_fNsigmaTpc_kTOF[i],200,"NsigmaTpc_kTOF_%s in DCAxyCut;p/|z| (GeV/c);n_{#sigma_{TPC}}^{%s}",name[i],name[i]);
 201       fNsigmaTpc_kTOF[iB][i] = new TH2F(name_fNsigmaTpc_kTOF[i],title_fNsigmaTpc_kTOF[i],hbins[0],0,5,hbins[1],-5,5);
 202     }
 203
 204     if(kSignalCheck==1) {hbins[0]=1000; hbins[1]=1300;}
 205     else if(kSignalCheck==0) {hbins[0]=1; hbins[1]=1;}
 206     else if(kSignalCheck==2) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=100; hbins[1]=260;}
 207     fBetaTofVSp[iB][0] = new TH2F("fBetaTofVSp_pos","#beta_{TOF} vs p/|z| (positive charge);p(GeV/c);#beta_{TOF}",hbins[0],0,5,hbins[1],0.4,1.05);
 208     fBetaTofVSp[iB][1] = new TH2F("fBetaTofVSp_neg","#beta_{TOF} vs p/|z| (negative charge);p(GeV/c);#beta_{TOF}",hbins[0],0,5,hbins[1],0.4,1.05);
 209
 210     Char_t name_hBetaExp[nPart][200];
 211     Char_t title_hBetaExp[nPart][200];
 212     for(Int_t i=0;i<nPart;i++) {
 213       snprintf(name_hBetaExp[i],200,"hBetaTofVsP_Exp_%s",namePart[i]);
 214       snprintf(title_hBetaExp[i],200,"Expected #beta_{TOF} vs p/|z| of %s;p/|z| (GeV/c); #beta_{TOF}",namePart[i]);
 215       hBetaExp[iB][i] = new TProfile(name_hBetaExp[i],title_hBetaExp[i],1,0,5,0.4,1.05,"");//,400,0,5,0.4,1.05,""); toram
 216     }
 217
 218     Char_t name_fNsigmaTof[nPart][200];
 219     Char_t title_fNsigmaTof[nPart][200];
 220     if(kSignalCheck==1) {hbins[0]=100; hbins[1]=100;}
 221     else {hbins[0]=1; hbins[1]=1;}
 222     for(Int_t i=0;i<nPart;i++) {
 223       snprintf(name_fNsigmaTof[i],200,"NsigmaTof_%s",namePart[i]);
 224       snprintf(title_fNsigmaTof[i],200,"NsigmaTof_%s;p_{T}/|z| (GeV/c);n_{#sigma_{TOF}}^{%s}",namePart[i],namePart[i]);
 225       fNsigmaTof[iB][i] = new TH2F(name_fNsigmaTof[i],title_fNsigmaTof[i],hbins[0],0,5,hbins[1],-5,5);
 226     }
 227
 228     Char_t name_fNsigmaTof_DcaCut[nSpec][200];
 229     Char_t title_fNsigmaTof_DcaCut[nSpec][200];
 230     if(kSignalCheck==1) {hbins[0]=100; hbins[1]=100;}
 231     else {hbins[0]=1; hbins[1]=1;}
 232     for(Int_t i=0;i<nSpec;i++) {
 233       snprintf(name_fNsigmaTof_DcaCut[i],200,"NsigmaTof_DcaCut_%s",name[i]);
 234       snprintf(title_fNsigmaTof_DcaCut[i],200,"NsigmaTof_%s with DCAxyCut;p_{T}/|z| (GeV/c);n_{#sigma_{TOF}}^{%s}",name[i],name[i]);
 235       fNsigmaTof_DcaCut[iB][i] = new TH2F(name_fNsigmaTof_DcaCut[i],title_fNsigmaTof_DcaCut[i],hbins[0],0,5,hbins[1],-5,5);
 236     }
 237
 238     if(kSignalCheck==1) {hbins[0]=8000; hbins[1]=100;}
 239     else {hbins[0]=1; hbins[1]=1;}
 240     fM2vsP_NoTpcCut[iB][0][0] = new TH2F("fM2vsP_NoTpcCut_pos","m^{2}/z^{2}_{TOF} vs p/|z| (positive charge);m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",hbins[0],0,10,hbins[1],0,5);
 241     fM2vsP_NoTpcCut[iB][0][1] = new TH2F("fM2vsP_NoTpcCut_neg","m^{2}/z^{2}_{TOF} vs p/|z| (negative charge);m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",hbins[0],0,10,hbins[1],0,5);
 242
 243     if(kSignalCheck==1) {hbins[0]=8000; hbins[1]=100;}
 244     else if(kSignalCheck==0) {hbins[0]=1; hbins[1]=1;}
 245     else if(kSignalCheck==2) {hbins[0]=1; hbins[1]=1;}// {hbins[0]=1000; hbins[1]=100;} toram
 246     fM2vsP_NoTpcCut[iB][1][0] = new TH2F("fM2vsP_NoTpcCut_DCAxyCut_pos","m^{2}/z^{2}_{TOF} vs p/|z| (positive charge) with DCAxy cut;m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",hbins[0],0,10,hbins[1],0,5);
 247     fM2vsP_NoTpcCut[iB][1][1] = new TH2F("fM2vsP_NoTpcCut_DCAxyCut_neg","m^{2}/z^{2}_{TOF} vs p/|z| (negative charge) with DCAxy cut;m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",hbins[0],0,10,hbins[1],0,5);
 248
 249     Char_t name_fM2vsP[2][18][300];
 250     Char_t title_fM2vsP[2][18][300];
 251
 252     for(Int_t i=0;i<nSpec;i++) {
 253       snprintf(name_fM2vsP[0][i],300,"fM2vsPc_%s",name[i]);
 254       snprintf(title_fM2vsP[0][i],300,"m^{2}/z^{2}_{TOF} vs p/|z| of %s with a NsigmaTpcCut (pReco->pTrue for nuclei);m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",name[i]);
 255
 256       snprintf(name_fM2vsP[1][i],300,"fM2vsPc_%s_DCAxyCut",name[i]);
 257       snprintf(title_fM2vsP[1][i],300,"m^{2}/z^{2}_{TOF} vs p/|z| of %s with a NsigmaTpcCut and with the DCAxy cut (pReco->pTrue for nuclei);m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4});p/|z| (GeV/c)",name[i]);
 258
 259       if(kSignalCheck==1) {hbins[0]=8000; hbins[1]=100;}
 260       else {hbins[0]=1; hbins[1]=1;}
 261       fM2vsP[iB][0][i] = new TH2F(name_fM2vsP[0][i],title_fM2vsP[0][i],hbins[0],0,10,hbins[1],0,5);
 262
 263       if(kSignalCheck==1) {hbins[0]=8000; hbins[1]=100;}
 264       else if(kSignalCheck==0) {hbins[0]=1; hbins[1]=1;}
 265       else if(kSignalCheck==2) {hbins[0]=1; hbins[1]=1;}//{hbins[0]=1000; hbins[1]=100;} toram
 266       fM2vsP[iB][1][i] = new TH2F(name_fM2vsP[1][i],title_fM2vsP[1][i],hbins[0],0,10,hbins[1],0,5);
 267     }
 268
 269     if(kSignalCheck==1) {hbins[0]=4000; hbins[1]=1000;}
 270     else {hbins[0]=1; hbins[1]=1;}
 271     fM2vsZ[iB][0] = new TH2F("fM2vsZ","m^{2}/z^{2}_{TOF} vs z_{TPC} Integrated p_{T};z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 272     fM2vsZ[iB][1] = new TH2F("fM2vsZ_0.5pT1.0","m^{2}/z^{2}_{TOF} vs z_{TPC} 0.5<pT<1.0;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 273     fM2vsZ[iB][2] = new TH2F("fM2vsZ_1.0pT1.5","m^{2}/z^{2}_{TOF} vs z_{TPC} 1.0<pT<1.5;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 274     fM2vsZ[iB][3] = new TH2F("fM2vsZ_1.5pT2.0","m^{2}/z^{2}_{TOF} vs z_{TPC} 1.5<pT<2.0;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 275     fM2vsZ[iB][4] = new TH2F("fM2vsZ_2.0pT2.5","m^{2}/z^{2}_{TOF} vs z_{TPC} 2.0<pT<2.5;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 276     fM2vsZ[iB][5] = new TH2F("fM2vsZ_2.5pT3.0","m^{2}/z^{2}_{TOF} vs z_{TPC} 2.5<pT<3.0;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 277     fM2vsZ[iB][6] = new TH2F("fM2vsZ_3.0pT3.5","m^{2}/z^{2}_{TOF} vs z_{TPC} 3.0<pT<3.5;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 278     fM2vsZ[iB][7] = new TH2F("fM2vsZ_3.5pT4.0","m^{2}/z^{2}_{TOF} vs z_{TPC} 3.5<pT<4.0;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 279     fM2vsZ[iB][8] = new TH2F("fM2vsZ_4.0pT4.5","m^{2}/z^{2}_{TOF} vs z_{TPC} 4.0<pT<4.5;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 280     fM2vsZ[iB][9] = new TH2F("fM2vsZ_4.5pT5.0","m^{2}/z^{2}_{TOF} vs z_{TPC} 2.0<pT<2.5;z_{TPC};m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",hbins[0],-4,4,hbins[1],0,10);
 281
 282     Char_t name_hDCAxy[18][nbin][200];
 283     Char_t title_hDCAxy[18][nbin][200];
 284     Char_t name_hDCAz[18][nbin][200];
 285     Char_t title_hDCAz[18][nbin][200];
 286     for(Int_t iS=0;iS<nSpec;iS++) {
 287       for(Int_t j=0;j<nbin;j++) {
 288         snprintf(name_hDCAxy[iS][j],200,"hDCAxy_%s_%s",name[iS],name_nbin[j]);
 289         snprintf(title_hDCAxy[iS][j],200,"hDCAxy_%s_%s;DCA_{xy} (cm)",name[iS],name_nbin[j]);
 290         hDCAxy[iB][iS][j] = new TH1D(name_hDCAxy[iS][j],title_hDCAxy[iS][j],875,-3.5,3.5);
 291
 292         snprintf(name_hDCAz[iS][j],200,"hDCAz_%s_%s",name[iS],name_nbin[j]);
 293         snprintf(title_hDCAz[iS][j],200,"hDCAz_%s_%s;DCA_{z} (cm)",name[iS],name_nbin[j]);
 294         hDCAz[iB][iS][j] = new TH1D(name_hDCAz[iS][j],title_hDCAz[iS][j],875,-3.5,3.5);
 295       }
 296     }
 297
 298     Char_t name_hM2CutDCAxy[18][nbin][200];
 299     Char_t title_hM2CutDCAxy[18][nbin][200];
 300     Char_t name_hM2CutGroundDCAxy[18][nbin][200];
 301     Char_t title_hM2CutGroundDCAxy[18][nbin][200];
 302     for(Int_t iS=0;iS<nSpec;iS++) {
 303       for(Int_t j=0;j<nbin;j++) {
 304         snprintf(name_hM2CutDCAxy[iS][j],200,"hM2_CutDCAxy_%s_%s",name[iS],name_nbin[j]);
 305         snprintf(title_hM2CutDCAxy[iS][j],200,"m^{2}/z^{2} Tof distribution of %s in DCAxy cut and in %s;m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",name[iS],name_nbin[j]);
 306         snprintf(name_hM2CutGroundDCAxy[iS][j],200,"hM2_GroundCatDCAxy_%s_%s",name[iS],name_nbin[j]);
 307         snprintf(title_hM2CutGroundDCAxy[iS][j],200,"m^{2}/z^{2} Tof distribution of %s in the bkg. of DCAxy and in %s;m^{2}/z^{2}_{TOF} (GeV^{2}/c^{4})",name[iS],name_nbin[j]);
 308       }
 309     }
 310
 311     const Int_t BinM2pT[nPart]={1,1,600,250,500,500,1000,400,600};
 312     const Double_t RangeM2min[nPart]={0.0,0.0,-0.1,0.0,0.0,0.0,0.0,0.0,0.0};
 313     const Double_t RangeM2max[nPart]={1.0,1.0,0.5,2.0,4.0,6.0,12.0,4.0,6.0};
 314
 315     for(Int_t iS=0;iS<nPart;iS++) {
 316       for(Int_t j=0;j<nbin;j++) {
 317
 318         hM2CutDCAxy[iB][iS][j] = new TH1D(name_hM2CutDCAxy[iS][j],title_hM2CutDCAxy[iS][j],BinM2pT[iS],RangeM2min[iS],RangeM2max[iS]);
 319         hM2CutGroundDCAxy[iB][iS][j] = new TH1D(name_hM2CutGroundDCAxy[iS][j],title_hM2CutGroundDCAxy[iS][j],BinM2pT[iS],RangeM2min[iS],RangeM2max[iS]);
 320
 321         hM2CutDCAxy[iB][iS+nPart][j] = new TH1D(name_hM2CutDCAxy[iS+nPart][j],title_hM2CutDCAxy[iS+nPart][j],BinM2pT[iS],RangeM2min[iS],RangeM2max[iS]);
 322         hM2CutGroundDCAxy[iB][iS+nPart][j] = new TH1D(name_hM2CutGroundDCAxy[iS+nPart][j],title_hM2CutGroundDCAxy[iS+nPart][j],BinM2pT[iS],RangeM2min[iS],RangeM2max[iS]);
 323       }
 324     }
 325
 326     Char_t name_fPmeanVsBetaGamma[18][200];
 327     Char_t title_fPmeanVsBetaGamma[18][200];
 328
 329     hbins[0]=200; hbins[1]=200;
 330     for(Int_t iS=0;iS<nSpec;iS++) {
 331       snprintf(name_fPmeanVsBetaGamma[iS],200,"fPmeanVsPvtx_%s",name[iS]);
 332       snprintf(title_fPmeanVsBetaGamma[iS],200,"<p>/p_{vtx} vs #beta#gamma of %s (in DCAxyCut);p_{vtx}/m_{%s};<p>_{%s}/p_{vtx}",name[iS],name[iS],name[iS]);
 333       fPmeanVsBetaGamma[iB][iS]=new TH2F(name_fPmeanVsBetaGamma[iS],title_fPmeanVsBetaGamma[iS],hbins[0],0,10,hbins[1],0.8,1.2);
 334     }
 335
 336     Char_t name_prPmeanVsBetaGamma[18][200];
 337     Char_t title_prPmeanVsBetaGamma[18][200];
 338
 339     for(Int_t iS=0;iS<nSpec;iS++) {
 340       snprintf(name_prPmeanVsBetaGamma[iS],200,"prPmeanVsPvtx_%s",name[iS]);
 341       snprintf(title_prPmeanVsBetaGamma[iS],200,"<p>/p_{vtx} vs #beta#gamma of %s (in DCAxyCut);p_{vtx}/m_{%s};<p>_{%s}/p_{vtx}",name[iS],name[iS],name[iS]);
 342       prPmeanVsBetaGamma[iB][iS]=new TProfile(name_prPmeanVsBetaGamma[iS],title_prPmeanVsBetaGamma[iS],hbins[0],0,10,0.8,1.2,"");
 343     }
 344
 345     //for (bar)d
 346     fPvtxTrueVsReco[0]=new TF2("fcorr_d","([0]*TMath::Power(x,[1])+[2])*(TMath::Power((TMath::Exp([3]*x)+[4]),[5]*TMath::Power(y,[6])));|#eta|;p_{true}/p_{reco}",0.0001,100,0,1);//for (bar)d
 347     fPvtxTrueVsReco[0]->SetParameter(0,0.031263);
 348     fPvtxTrueVsReco[0]->SetParameter(1,-3.276770);
 349     fPvtxTrueVsReco[0]->SetParameter(2,1.000113);
 350     fPvtxTrueVsReco[0]->SetParameter(3,-5.195875);
 351     fPvtxTrueVsReco[0]->SetParameter(4,1.000674);
 352     fPvtxTrueVsReco[0]->SetParameter(5,2.870503);
 353     fPvtxTrueVsReco[0]->SetParameter(6,3.777729);
 354
 355     fPvtxTrueVsReco[0]->SetNpx(fPvtxTrueVsReco[0]->GetNpx()*10);
 356
 357     //for (bar)He3
 358     fPvtxTrueVsReco[1]=new TF2("fcorr_He","([0]*TMath::Power(x,[1])+[2])*(TMath::Power((TMath::Exp([3]*x)+[4]),[5]*TMath::Power(y,[6])));|#eta|;p_{true}/p_{reco}",0.0001,100,0,1);//for (bar)He3
 359     fPvtxTrueVsReco[1]->SetParameter(0,0.037986);
 360     fPvtxTrueVsReco[1]->SetParameter(1,-2.707620);
 361     fPvtxTrueVsReco[1]->SetParameter(2,1.000742);
 362     fPvtxTrueVsReco[1]->SetParameter(3,-4.934743);
 363     fPvtxTrueVsReco[1]->SetParameter(4,1.001640);
 364     fPvtxTrueVsReco[1]->SetParameter(5,2.744372);
 365     fPvtxTrueVsReco[1]->SetParameter(6,3.528561);
 366
 367     fPvtxTrueVsReco[1]->SetNpx(fPvtxTrueVsReco[1]->GetNpx()*10);
 368
 369     prPvtxTrueVsReco[iB][0]=new TProfile("prPvtxTrueVsReco_d","p_{true} vs p_{reco} of d and dbar;p_{reco} (GeV/c); p_{true}/p_{reco} (d)",200,0,10);
 370     prPvtxTrueVsReco[iB][1]=new TProfile("prPvtxTrueVsReco_He3","p_{true} vs p_{reco} of He3 and He3bar;p_{reco} (GeV/c);p_{true}/p_{reco} (He3)",200,0,10);
 371
 372     Char_t nameTemp[10][200];
 373     snprintf(nameTemp[0],200,"#pi^{+}");
 374     snprintf(nameTemp[1],200,"K^{+}");
 375     snprintf(nameTemp[2],200,"p");
 376     snprintf(nameTemp[3],200,"d");
 377     snprintf(nameTemp[4],200,"He3");
 378     snprintf(nameTemp[5],200,"#pi^{-}");
 379     snprintf(nameTemp[6],200,"K^{-}");
 380     snprintf(nameTemp[7],200,"#bar{p}");
 381     snprintf(nameTemp[8],200,"#bar{d}");
 382     snprintf(nameTemp[9],200,"#bar{He3}");
 383
 384     Char_t name_fPmeanVsBGcorr[10][200];
 385     for(Int_t i=0;i<10;i++) {
 386       snprintf(name_fPmeanVsBGcorr[i],200,"fPmeanVsBGcorr_%s",nameTemp[i]);
 387       fPmeanVsBGcorr[0][i]=new TF1(name_fPmeanVsBGcorr[i],"[2]-[0]*TMath::Power(x,[1]);p_{vtx}/m;<p>/p",0.0001,100);
 388       fPmeanVsBGcorr[1][i]=new TF1(name_fPmeanVsBGcorr[i],"[2]-[0]*TMath::Power(x,[1]);p_{vtx}/m;<p>/p",0.0001,100);
 389       //fPmeanVsBGcorr[i]->SetParameters(pars_fPmeanVsBGcorr[i]);
 390       //fPmeanVsBGcorr[i]->SetNpx(fPmeanVsBGcorr[i]->GetNpx()*10);
 391     }
 392     SetPmeanCorrections();
 393
 394     Char_t name_prPmeanVsBGcorr[10][200];
 395     Char_t title_prPmeanVsBGcorr[10][200];
 396
 397     hbins[0]=200;
 398     for(Int_t iS=0;iS<10;iS++) {
 399       snprintf(name_prPmeanVsBGcorr[iS],200,"prPmeanVsBGcorr_%s",nameTemp[iS]);
 400       snprintf(title_prPmeanVsBGcorr[iS],200,"<p>/p_{vtx} vs #beta#gamma of %s as parameterized in input TF1 (in DCAxyCut);p_{vtx}/m_{%s};<p>_{%s}/p_{vtx}",nameTemp[iS],nameTemp[iS],nameTemp[iS]);
 401       prPmeanVsBGcorr[iB][iS]=new TProfile(name_prPmeanVsBGcorr[iS],title_prPmeanVsBGcorr[iS],hbins[0],0,10,0.8,1.2,"");
 402     }
 403
 404     fList[iB]->Add(htemp[iB]);
 405     for(Int_t i=0;i<2;i++) fList[iB]->Add(hCentrality[iB][i]);
 406     for(Int_t i=0;i<2;i++) fList[iB]->Add(hZvertex[iB][i]);
 407     fList[iB]->Add(hEta[iB]);
 408     fList[iB]->Add(hPhi[iB]);
 409     //fList[iB]->Add(fEtaPhi[iB]);
 410     fList[iB]->Add(hNTpcCluster[iB]);
 411     fList[iB]->Add(hNTrdSlices[iB]);
 412     //for(Int_t i=0;i<2;i++) fList[iB]->Add(fdEdxVSp[iB][i]);
 413     //for(Int_t i=0;i<nPart;i++) fList[iB]->Add(hDeDxExp[iB][i]);
 414     //for(Int_t i=0;i<nPart;i++) fList[iB]->Add(fNsigmaTpc[iB][i]);
 415     for(Int_t i=0;i<nPart;i++) {
 416       if(kSignalCheck!=1)
 417         if(i<3 || i==6 || i==8) continue;//e,mu,pi,t,he4 excluded
 418       //fList[iB]->Add(fNsigmaTpc_kTOF[iB][i]);
 419       //fList[iB]->Add(fNsigmaTpc_kTOF[iB][i+nPart]);
 420     }
 421     //for(Int_t i=0;i<2;i++) fList[iB]->Add(fBetaTofVSp[iB][i]);
 422     //for(Int_t i=0;i<nPart;i++) fList[iB]->Add(hBetaExp[iB][i]);
 423     //for(Int_t i=0;i<nPart;i++) fList[iB]->Add(fNsigmaTof[iB][i]);
 424     for(Int_t i=0;i<nPart;i++) {
 425       if(kSignalCheck!=1)
 426         if(i<3 || i==6 || i==8) continue;//e,mu,pi,t,he4 excluded
 427       //fList[iB]->Add(fNsigmaTof_DcaCut[iB][i]);
 428       //fList[iB]->Add(fNsigmaTof_DcaCut[iB][i+nPart]);
 429     }
 430     //for(Int_t i=0;i<2;i++) fList[iB]->Add(fM2vsP_NoTpcCut[iB][0][i]);
 431     //for(Int_t i=0;i<2;i++) fList[iB]->Add(fM2vsP_NoTpcCut[iB][1][i]);
 432     for(Int_t i=0;i<nPart;i++) {
 433       if(i<3 || i==6 || i==8) continue;//e,mu,pi,t,he4 excluded
 434       //fList[iB]->Add(fM2vsP[iB][0][i]);
 435       //fList[iB]->Add(fM2vsP[iB][0][i+nPart]);
 436     }
 437     for(Int_t i=0;i<nPart;i++){
 438       if(kSignalCheck!=1)
 439         if(i<3 || i==6 || i==8) continue;//e,mu,pi,t,he4 excluded
 440       fList[iB]->Add(fM2vsP[iB][1][i]);
 441       fList[iB]->Add(fM2vsP[iB][1][i+nPart]);
 442     }
 443     for(Int_t i=0;i<2;i++){
 444       //fList[iB]->Add(fPvtxTrueVsReco[i]);
 445       fList[iB]->Add(prPvtxTrueVsReco[iB][i]);
 446     }
 447     if(iMtof!=1) {
 448       for(Int_t i=0;i<nPart;i++){
 449         if(i<2) continue;//e,mu excluded
 450         fList[iB]->Add(fPmeanVsBetaGamma[iB][i]);
 451         fList[iB]->Add(prPmeanVsBetaGamma[iB][i]);
 452         fList[iB]->Add(fPmeanVsBetaGamma[iB][i+nPart]);
 453         fList[iB]->Add(prPmeanVsBetaGamma[iB][i+nPart]);
 454       }
 455     }
 456     if(iMtof>2) {
 457       //for(Int_t i=0;i<10;i++)fList[iB]->Add(fPmeanVsBGcorr[i]);
 458       for(Int_t i=0;i<10;i++)fList[iB]->Add(prPmeanVsBGcorr[iB][i]);
 459     }
 460     //for(Int_t i=0;i<10;i++) fList[iB]->Add(fM2vsZ[iB][i]);
 461     for(Int_t i=0;i<nPart;i++){
 462       if(kSignalCheck!=1)
 463         if(i<3 || i==6 || i==8) continue;//e,mu,pi,t,he4 excluded
 464       for(Int_t j=0;j<nbin;j++){
 465         fList[iB]->Add(hDCAxy[iB][i][j]);
 466         fList[iB]->Add(hDCAz[iB][i][j]);
 467         fList[iB]->Add(hM2CutDCAxy[iB][i][j]);
 468         fList[iB]->Add(hM2CutGroundDCAxy[iB][i][j]);
 469         fList[iB]->Add(hDCAxy[iB][i+nPart][j]);
 470         fList[iB]->Add(hDCAz[iB][i+nPart][j]);
 471         fList[iB]->Add(hM2CutDCAxy[iB][i+nPart][j]);
 472         fList[iB]->Add(hM2CutGroundDCAxy[iB][i+nPart][j]);
 473       }
 474     }
 475
 476     // Post output data.
 477     PostData(1, fList[0]);
 478     PostData(2, fList[1]);
 479
 480   }//end iB loop
 481 }
 482 //______________________________________________________________________________
 483 void AliAnalysisNucleiMass::UserExec(Option_t *)
 484 {
 485   // Main loop
 486   // Called for each event
 487
 488   fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
 489   fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 490   if(!fAOD && !fESD){
 491     Printf("%s:%d AODEvent and ESDEvent not found in Input Manager",(char*)__FILE__,__LINE__);
 492     return;
 493   }
 494
 495   if(fESD) fEvent = fESD;
 496   else fEvent = fAOD;
 497
 498   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 499   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 500   fPIDResponse=inputHandler->GetPIDResponse();
 501
 502   //--------------------------Magnetic field polarity--------------------
 503   Double_t fBfield=fEvent->GetMagneticField();
 504   if(fBfield<0.0) iBconf=0;//B--
 505   else iBconf=1;//B++
 506   for(Int_t i=0;i<nBconf;i++) htemp[i]->Fill(fBfield);
 507
 508   //--------------------------Centrality--------------------------------
 509   Double_t v0Centr  = -10.;
 510   AliCentrality *centrality = fEvent->GetCentrality();
 511   if (centrality){
 512     v0Centr=centrality->GetCentralityPercentile("V0M"); // VZERO
 513   }
 514   hCentrality[iBconf][0]->Fill(v0Centr);
 515
 516   //-------------------------zVertex determination of event----------------
 517   Double_t zvtx = 9999.9;
 518   const AliVVertex* vtxEVENT = fEvent->GetPrimaryVertex();
 519   if(vtxEVENT->GetNContributors()>0) zvtx = vtxEVENT->GetZ();
 520
 521   hZvertex[iBconf][0]->Fill(zvtx);
 522
 523   //---------------------------EVENT CUTS-----------------------------
 524   if(TMath::Abs(zvtx) < 10.0 && v0Centr>Centrality[0] && v0Centr<Centrality[1]){
 525
 526     hCentrality[iBconf][1]->Fill(v0Centr);
 527     hZvertex[iBconf][1]->Fill(zvtx);
 528
 529     Int_t nTracks = fEvent->GetNumberOfTracks();
 530
 531     //----------------------loop on the TRACKS-----------------------------
 532     for(Int_t iT = 0; iT < nTracks; iT++) {
 533       AliVTrack* track = (AliVTrack *) fEvent->GetTrack(iT);
 534
 535       if (!track){
 536         continue;
 537       }
 538
 539      //For the geometrical cuts
 540       Double_t eta = track->Eta();
 541
 542       Bool_t trkFlag = 0;
 543       trkFlag = ((AliAODTrack *) track)->TestFilterBit(FilterBit);
 544       //TestFilterBit(16) -- Standard Cuts with very loose DCA: GetStandardITSTPCTrackCuts2011(kFALSE) && SetMaxDCAToVertexXY(2.4) && SetMaxDCAToVertexZ(3.2) && SetDCaToVertex2D(kTRUE)
 545       //TestFilterBit(32) (STARDARD) -- Standard Cuts with very tight DCA cut ( 7sigma^primaries: 7*(0.0015+0.0050/pt^1.1) ) : GetStandardITSTPCTrackCuts2011().
 546
 547       //Cut on the Minumum Number of the TPC clusters
 548       Bool_t isMinTpcCluster=kFALSE;
 549       Int_t nTpcCluster=0;
 550       nTpcCluster=track->GetTPCNcls();
 551       if(nTpcCluster>NminTpcCluster) isMinTpcCluster=kTRUE;
 552
 553       //-------------------------------------start TRACK CUTS----------------------------------
 554       if ((track->Pt() < 0.2) || (eta<EtaLimit[0]) || (eta>EtaLimit[1]) || !trkFlag || !isMinTpcCluster)
 555         continue;
 556
 557       //Vertex determination
 558       Double_t b[2] = {-99., -99.};
 559       Double_t bCov[3] = {-99., -99., -99.};
 560       if (!track->PropagateToDCA(fEvent->GetPrimaryVertex(), fEvent->GetMagneticField(), 100., b, bCov))
 561         continue;
 562
 563       Double_t DCAxy = b[0];
 564       Double_t DCAz = b[1];
 565
 566       //Cut on the DCAz
 567       Bool_t isDCAzCut=kFALSE;
 568       if(DCAz<DCAzCut) isDCAzCut=kTRUE;
 569
 570       if(!isDCAzCut)
 571         continue;
 572
 573       //For the Tpc purity cut
 574       Double_t dedx = track->GetTPCsignal();
 575       if(dedx<10) continue;
 576
 577       Int_t nTrdSlices = track->GetNumberOfTRDslices();
 578       if(nTrdSlices<2 && iTrdCut==1) continue;
 579       if(nTrdSlices>0 && iTrdCut==2) continue;
 580
 581       //-------------------------------------end TRACK CUTS----------------------------------
 582
 583       //-------------------------------------Track info--------------------------------------
 584       Double_t phi= track->Phi();
 585
 586       hEta[iBconf]->Fill(eta);
 587       hPhi[iBconf]->Fill(phi);
 588       fEtaPhi[iBconf]->Fill(eta,phi);
 589       hNTpcCluster[iBconf]->Fill(nTpcCluster);
 590       hNTrdSlices[iBconf]->Fill(nTrdSlices);
 591
 592       Double_t charge = (Double_t)track->Charge();
 593       Double_t p = track->P();
 594       Double_t pt = track->Pt();
 595       Double_t tof  = track->GetTOFsignal()-fPIDResponse->GetTOFResponse().GetStartTime(p);
 596       Double_t pTPC = track->GetTPCmomentum();
 597       Double_t beta = 0.0;
 598       Double_t M2 = 999.9;
 599       Double_t Z2 = 999.9;
 600
 601       kTOF = (track->GetStatus() & AliVTrack::kTOFout) && (track->GetStatus() & AliVTrack::kTIME);
 602
 603       //-----------------------------TPC info------------------------------
 604       Double_t nsigmaTPC[nPart];
 605       Double_t expdedx[nPart];
 606
 607       Int_t stdFlagPid[9] = {1,2,4,8,16,32,64,128,256};//e,#mu,#pi,K,p,d,t,3He,4He
 608       Int_t FlagPid = 0;
 609
 610       for(Int_t iS=0;iS<9;iS++){
 611         nsigmaTPC[iS] = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType) iS);
 612         //TPC identification:
 613         if(TMath::Abs(nsigmaTPC[iS])<NsigmaTpcCut) {
 614           FlagPid += ((Int_t)TMath::Power(2,iS));
 615         }
 616       }
 617       //Correction of the momentum to the vertex for (anti)nuclei
 618       Double_t pC[9];
 619       for(Int_t iS=0;iS<9;iS++) pC[iS]=p;
 620       this->MomVertexCorrection(p,pC,eta,FlagPid);
 621
 622       //More TPC info:
 623       for(Int_t iS=0;iS<9;iS++){
 624         expdedx[iS] = fPIDResponse->GetTPCResponse().GetExpectedSignal(track, (AliPID::EParticleType) iS, AliTPCPIDResponse::kdEdxDefault, kTRUE);
 625         hDeDxExp[iBconf][iS]->Fill(pTPC,expdedx[iS]);
 626         nsigmaTPC[iS] = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType) iS);
 627         fNsigmaTpc[iBconf][iS]->Fill(pTPC,nsigmaTPC[iS]);
 628         if(charge>0) {//positive particle
 629           if(kTOF && (TMath::Abs(DCAxy)<DCAxyCut)) fNsigmaTpc_kTOF[iBconf][iS]->Fill(p,nsigmaTPC[iS]);
 630         }
 631         else {//negative particle
 632           if(kTOF && (TMath::Abs(DCAxy)<DCAxyCut)) fNsigmaTpc_kTOF[iBconf][iS+nPart]->Fill(p,nsigmaTPC[iS]);
 633         }
 634         /*
 635           if(TMath::Abs(nsigmaTPC[iS])<NsigmaTpcCut) {
 636           FlagPid += ((Int_t)TMath::Power(2,iS));
 637           }*/
 638       }
 639
 640       if(charge>0) fdEdxVSp[iBconf][0]->Fill(pTPC,dedx);
 641       else fdEdxVSp[iBconf][1]->Fill(pTPC,dedx);
 642
 643       //-----------------------------TOF info------------------------------
 644
 645       Double_t massOverZ[9] = {0.000511,0.105658,0.139570,0.493677,0.938272,1.875612859,2.808921005,1.404195741,1.863689620};
 646
 647       //----------------------------------------kTOF available-----------------------------
 648
 649       if(kTOF) {
 650         Double_t exptimes[9];
 651         track->GetIntegratedTimes(exptimes);
 652         //Integrated times of the Nuclei:
 653         for(Int_t iN=5;iN<9;iN++) {
 654           exptimes[iN] = exptimes[4]*exptimes[4]*(massOverZ[iN]*massOverZ[iN]/p/p+1)/(massOverZ[4]*massOverZ[4]/p/p+1);
 655           exptimes[iN] = TMath::Sqrt(exptimes[iN]);
 656         }
 657
 658         beta=exptimes[0];
 659         beta=beta/tof;//beta = L/tof/c = t_e/tof
 660
 661         Int_t FlagPidTof = 0;
 662         Double_t NsigmaTofCut = 2.0;
 663
 664         Double_t nsigmaTOF[9];
 665         for(Int_t iS=0;iS<9;iS++){
 666           nsigmaTOF[iS] = fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType) iS);
 667           fNsigmaTof[iBconf][iS]->Fill(pt,nsigmaTOF[iS]);
 668           if(charge>0) {
 669             hBetaExp[iBconf][iS]->Fill(p,exptimes[0]/exptimes[iS]);
 670             if(TMath::Abs(DCAxy)<DCAxyCut) fNsigmaTof_DcaCut[iBconf][iS]->Fill(pt,nsigmaTOF[iS]);
 671           }
 672           else {
 673             hBetaExp[iBconf][iS+nPart]->Fill(p,exptimes[0]/exptimes[iS]);
 674             if(TMath::Abs(DCAxy)<DCAxyCut) fNsigmaTof_DcaCut[iBconf][iS+nPart]->Fill(pt,nsigmaTOF[iS]);
 675           }
 676
 677           //TOF identification:
 678           if(TMath::Abs(nsigmaTOF[iS])<NsigmaTofCut) {
 679             FlagPidTof += ((Int_t)TMath::Power(2,iS));
 680           }
 681         }
 682
 683         if(charge>0) fBetaTofVSp[iBconf][0]->Fill(p,beta);
 684         else fBetaTofVSp[iBconf][1]->Fill(p,beta);
 685
 686         this->GetMassFromPvertex(beta,p,M2);
 687         this->GetZTpc(dedx,pTPC,M2,Z2);
 688
 689         Double_t Mass2[9];
 690         //-----------------------------M2 as a function of momentum to the primary vertex if iMtof==1---------------------------------
 691         if(iMtof==1) this->GetMassFromPvertexCorrected(beta,pC,Mass2);
 692
 693         if(iMtof>1) this->GetPmeanVsBetaGamma(exptimes,pC,FlagPid,FlagPidTof,charge,DCAxy);
 694
 695         //-----------------------------M2 as a function of expected times---------------------------------
 696         if(iMtof==2) this->GetMassFromExpTimes(beta,exptimes,Mass2);
 697
 698         //-----------------------------M2 as a function of mean momentum calculated from expected time and extrapolated to the (anti)nuclei---------------------------------
 699         if(iMtof>2) this->GetMassFromMeanMom(beta,exptimes,pC,charge,Mass2,FlagPid,FlagPidTof,DCAxy);
 700
 701         //-------------------------------Squared Mass TH2 distributions-----------------------
 702         if(charge>0) {
 703           //without TPC
 704           fM2vsP_NoTpcCut[iBconf][0][0]->Fill(M2,p);
 705           if(TMath::Abs(DCAxy)<DCAxyCut) fM2vsP_NoTpcCut[iBconf][1][0]->Fill(M2,p);
 706           //with TPC
 707           for(Int_t iS=0;iS<9;iS++) {
 708             M2=999.9;
 709             M2=Mass2[iS];
 710             //-----------------
 711             if(FlagPid & stdFlagPid[iS]) {
 712               fM2vsP[iBconf][0][iS]->Fill(M2,pC[iS]);
 713               if(TMath::Abs(DCAxy)<DCAxyCut) fM2vsP[iBconf][1][iS]->Fill(M2,pC[iS]);
 714             }
 715           }
 716         }
 717         else {//charge<0
 718           //without TPC
 719           fM2vsP_NoTpcCut[iBconf][0][1]->Fill(M2,p);
 720           if(TMath::Abs(DCAxy)<DCAxyCut) fM2vsP_NoTpcCut[iBconf][1][1]->Fill(M2,p);
 721            //with TPC
 722           for(Int_t iS=0;iS<9;iS++) {
 723             M2=999.9;
 724             M2=Mass2[iS];
 725             //-----------------
 726             if(FlagPid & stdFlagPid[iS]) {
 727               fM2vsP[iBconf][0][iS+nPart]->Fill(M2,pC[iS]);
 728               if(TMath::Abs(DCAxy)<DCAxyCut) fM2vsP[iBconf][1][iS+nPart]->Fill(M2,pC[iS]);
 729             }
 730           }
 731         }
 732
 733         //------------------------------start DCA and Squared Mass TH1 distributions-------------------------
 734         Double_t binP[nbin+1];
 735         for(Int_t i=0;i<nbin+1;i++) {
 736           binP[i]=0.4+i*0.1;
 737         }
 738
 739         if(charge>0) {
 740           for(Int_t iS=0;iS<9;iS++) {
 741             M2=999.9;
 742             M2=Mass2[iS];
 743
 744             if(FlagPid & stdFlagPid[iS]) {
 745               for(Int_t j=0;j<nbin;j++) {
 746                 if(pC[iS]>binP[j] && pC[iS]<binP[j+1]) {
 747                   hDCAxy[iBconf][iS][j]->Fill(DCAxy);
 748                   hDCAxy[iBconf][iS][j]->Fill(-DCAxy);
 749                   hDCAz[iBconf][iS][j]->Fill(DCAz);
 750                   hDCAz[iBconf][iS][j]->Fill(-DCAz);
 751                   if(TMath::Abs(DCAxy)<DCAxyCut) {
 752                     hM2CutDCAxy[iBconf][iS][j]->Fill(M2);
 753                   }
 754                   if(TMath::Abs(DCAxy+0.5)<DCAxyCut) {
 755                     hM2CutGroundDCAxy[iBconf][iS][j]->Fill(M2);
 756                   }
 757                   break;
 758                 }
 759               }//end loop on the p bins (j)
 760             }
 761           }//end loop on the particle species (iS)
 762         }
 763         else {//charge<0
 764           for(Int_t iS=0;iS<9;iS++) {
 765             M2=999.9;
 766             M2=Mass2[iS];
 767
 768             if(FlagPid & stdFlagPid[iS]) {
 769               for(Int_t j=0;j<nbin;j++) {
 770                 if(pC[iS]>binP[j] && pC[iS]<binP[j+1]) {
 771                   hDCAxy[iBconf][iS+nPart][j]->Fill(DCAxy);
 772                   hDCAxy[iBconf][iS+nPart][j]->Fill(-DCAxy);
 773                   hDCAz[iBconf][iS+nPart][j]->Fill(DCAz);
 774                   hDCAz[iBconf][iS+nPart][j]->Fill(-DCAz);
 775                   if(TMath::Abs(DCAxy)<DCAxyCut) {
 776                     hM2CutDCAxy[iBconf][iS+nPart][j]->Fill(M2);
 777                   }
 778                   if(TMath::Abs(DCAxy+0.5)<DCAxyCut) {
 779                     hM2CutGroundDCAxy[iBconf][iS+nPart][j]->Fill(M2);
 780                   }
 781                   break;
 782                 }
 783               }//end loop on the p bins (j)
 784             }
 785           }//end loop on the particle species (iS)
 786         }
 787
 788         //-------------------------------------------------M2/Z2 vs Z-------------------------
 789
 790
 791         Double_t binCutPt[10] = {0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0};
 792         Double_t Z=999.9;
 793         if(Z2>0) Z=TMath::Sqrt(Z2);
 794
 795         fM2vsZ[iBconf][0]->Fill(charge*TMath::Sqrt(Z2),M2);
 796         for(Int_t i=1;i<10;i++) {
 797           if(pt>binCutPt[i-1] && pt<binCutPt[i]){
 798             fM2vsZ[iBconf][i]->Fill(charge*Z,M2);
 799             break;
 800           }
 801         }
 802
 803       }//end kTOF available
 804     }//end track loop
 805   }//end loop on the events
 806 }
 807
 808 //_____________________________________________________________________________
 809 void AliAnalysisNucleiMass::Terminate(Option_t *)
 810 {
 811   // Terminate loop
 812   Printf("Terminate()");
 813 }
 814 //_____________________________________________________________________________
 815 void AliAnalysisNucleiMass::MomVertexCorrection(Double_t p, Double_t *pC, Double_t eta, Int_t FlagPid){
 816
 817   Int_t stdFlagPid[9] = {1,2,4,8,16,32,64,128,256};//e,#mu,#pi,K,p,d,t,3He,4He
 818
 819   for(Int_t iS=0;iS<9;iS++) {
 820     if(FlagPid & stdFlagPid[iS]) {
 821       if(iS==5) {
 822         if(kPvtxCorr==1) pC[iS]=pC[iS]*fPvtxTrueVsReco[0]->Eval(pC[iS],TMath::Abs(eta));//for (bar)d
 823         prPvtxTrueVsReco[iBconf][0]->Fill(p,pC[iS]/p);
 824       }
 825       else if(iS==7) {
 826         if(kPvtxCorr==1) pC[iS]=pC[iS]*fPvtxTrueVsReco[1]->Eval(pC[iS],TMath::Abs(eta));//for (bar)He3
 827         prPvtxTrueVsReco[iBconf][1]->Fill(p,pC[iS]/p);
 828       }
 829     }
 830   }
 831
 832   return;
 833
 834 }
 835 //_____________________________________________________________________________
 836 void AliAnalysisNucleiMass::GetMassFromPvertex(Double_t beta, Double_t p, Double_t &M2) {
 837
 838   M2 = p*p*(1-beta*beta)/(beta*beta);
 839
 840   return;
 841
 842 }
 843 //_________________________________________________________________________________________________________________________
 844 void AliAnalysisNucleiMass::GetZTpc(Double_t dedx, Double_t pTPC, Double_t M2, Double_t &Z2) {
 845
 846   //z^2_tpc = dedx^{Tpc} / dedx^{exp,Tof}_{z=1}
 847
 848   Z2=999.9;
 849
 850   Double_t M=999.9;
 851   Double_t pTPC_pr=999.9;//rescaling of the pTPC for the proton
 852   Double_t expdedx_Tof=999.9;
 853
 854   if(M2>0) {
 855     M=TMath::Sqrt(M2);
 856     pTPC_pr=pTPC*0.938272/M;
 857     expdedx_Tof=fPIDResponse->GetTPCResponse().GetExpectedSignal(pTPC_pr,AliPID::kProton);
 858     if((dedx/expdedx_Tof)<0) return;
 859     Z2=TMath::Power(dedx/expdedx_Tof,0.862);
 860   }
 861
 862   return;
 863 }
 864 //_________________________________________________________________________________________________________________________
 865 void AliAnalysisNucleiMass::GetMassFromPvertexCorrected(Double_t beta, Double_t *pC, Double_t *Mass2) {
 866
 867   for(Int_t iS=0;iS<9;iS++) Mass2[iS] = pC[iS]*pC[iS]*(1-beta*beta)/(beta*beta);
 868
 869   return;
 870 }
 871 //____________________________________________________________________________________________________________
 872 void AliAnalysisNucleiMass::GetMassFromExpTimes(Double_t beta, Double_t *IntTimes, Double_t *Mass2) {
 873
 874   // m = p_exp/beta/gamma where p_exp = mPDG*beta_exp*gamma_exp; beta_exp = L/t_exp/c = t_e/t_exp ; beta=L/tof/c = t_e/tof
 875   // In this way m_tof = mPDG only if tof=t_exp
 876
 877   Double_t massOverZ[9] = {0.000511,0.105658,0.139570,0.493677,0.938272,1.875612859,2.808921005,1.404195741,1.863689620};
 878
 879   Double_t beta2Exp[9];
 880   Double_t p2Exp[9];
 881
 882   //Double_t pExp[9];
 883
 884   for(Int_t iS=0;iS<9;iS++) {
 885     beta2Exp[iS]=IntTimes[0]/IntTimes[iS];//beta = L/tof*c = t_e/tof
 886     beta2Exp[iS]=beta2Exp[iS]*beta2Exp[iS];
 887     if((1-beta2Exp[iS])==0) {
 888       Mass2[iS]=999.9;
 889       continue;
 890     }
 891     p2Exp[iS]=massOverZ[iS]*massOverZ[iS]*beta2Exp[iS]/(1-beta2Exp[iS]);
 892
 893     //--------------------for MC corrections
 894     if(p2Exp[iS]<0) {
 895       Mass2[iS]=999.9;
 896       continue;
 897     }
 898     //pExp[iS]=TMath::Sqrt(p2Exp[iS]);
 899
 900     //------------
 901     Mass2[iS]=p2Exp[iS]*(1-beta*beta)/(beta*beta);
 902   }//end loop on the particle species
 903
 904   return;
 905 }
 906 //____________________________________________________________________________________________________________
 907 void AliAnalysisNucleiMass::GetPmeanVsBetaGamma(Double_t *IntTimes, Double_t *pVtx, Int_t FlagPid, Int_t FlagPidTof, Double_t charge, Double_t DCAxy) {
 908
 909   // m = p_exp/beta/gamma where p_exp = mPDG*beta_exp*gamma_exp; beta_exp = L/t_exp/c = t_e/t_exp ; beta=L/tof/c = t_e/tof
 910   // In this way m_tof = mPDG only if tof=t_exp
 911
 912   Double_t massOverZ[9] = {0.000511,0.105658,0.139570,0.493677,0.938272,1.875612859,2.808921005,1.404195741,1.863689620};
 913
 914   Double_t beta2Exp[9];
 915   Double_t p2Exp[9];
 916
 917   Double_t pExp[9];
 918
 919   Int_t stdFlagPid[9] = {1,2,4,8,16,32,64,128,256};//e,#mu,#pi,K,p,d,t,3He,4He
 920
 921   for(Int_t iS=0;iS<9;iS++) {
 922     beta2Exp[iS]=IntTimes[0]/IntTimes[iS];//beta = L/tof*c = t_e/tof
 923     beta2Exp[iS]=beta2Exp[iS]*beta2Exp[iS];
 924     if((1-beta2Exp[iS])==0) {
 925       continue;
 926     }
 927     p2Exp[iS]=massOverZ[iS]*massOverZ[iS]*beta2Exp[iS]/(1-beta2Exp[iS]);
 928
 929     if(p2Exp[iS]<0) {
 930       continue;
 931     }
 932     pExp[iS]=TMath::Sqrt(p2Exp[iS]);
 933
 934     if((FlagPid & stdFlagPid[iS]) && (FlagPidTof & stdFlagPid[iS])) {
 935       if(TMath::Abs(DCAxy)>DCAxyCut) continue;
 936       if(charge>0){
 937         fPmeanVsBetaGamma[iBconf][iS]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
 938         prPmeanVsBetaGamma[iBconf][iS]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
 939       }
 940       else {
 941         fPmeanVsBetaGamma[iBconf][iS+nPart]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
 942         prPmeanVsBetaGamma[iBconf][iS+nPart]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
 943       }
 944     }
 945   }//end loop on the particle species
 946
 947   return;
 948
 949 }
 950 //____________________________________________________________________________________________________________
 951 void AliAnalysisNucleiMass::GetMassFromMeanMom(Double_t beta, Double_t *IntTimes, Double_t *pVtx, Double_t charge, Double_t *Mass2, Int_t FlagPid, Int_t FlagPidTof, Double_t DCAxy) {//Double_t *Mass2, Int_t iCorr
 952
 953   // m = p_exp/beta/gamma where p_exp = mPDG*beta_exp*gamma_exp; beta_exp = L/t_exp/c = t_e/t_exp ; beta=L/tof/c = t_e/tof
 954   // In this way m_tof = mPDG only if tof=t_exp
 955
 956   Double_t massOverZ[9] = {0.000511,0.105658,0.139570,0.493677,0.938272,1.875612859,2.808921005,1.404195741,1.863689620};
 957
 958   Double_t beta2Exp[9];
 959   Double_t p2Exp[9];
 960
 961   Double_t pExp[9];
 962
 963   Int_t stdFlagPid[9] = {1,2,4,8,16,32,64,128,256};//e,#mu,#pi,K,p,d,t,3He,4He
 964
 965   for(Int_t iS=0;iS<9;iS++) {
 966     if(iS==2 || iS==3 || iS==4 || iS==5 || iS==7) {
 967       if(charge>0) {
 968         if(iS!=7) p2Exp[iS]=pVtx[iS]*fPmeanVsBGcorr[iBconf][iS-2]->Eval(pVtx[iS]/massOverZ[iS]);
 969         else p2Exp[iS]=pVtx[iS]*fPmeanVsBGcorr[iBconf][iS-3]->Eval(pVtx[iS]/massOverZ[iS]);
 970       }
 971       else if(charge<0) {
 972         if(iS!=7) p2Exp[iS]=pVtx[iS]*fPmeanVsBGcorr[iBconf][iS+3]->Eval(pVtx[iS]/massOverZ[iS]);
 973         else p2Exp[iS]=pVtx[iS]*fPmeanVsBGcorr[iBconf][iS+2]->Eval(pVtx[iS]/massOverZ[iS]);
 974       }
 975       p2Exp[iS]*=p2Exp[iS];
 976     }
 977     else {
 978       beta2Exp[iS]=IntTimes[0]/IntTimes[iS];//beta = L/tof*c = t_e/tof
 979       beta2Exp[iS]=beta2Exp[iS]*beta2Exp[iS];
 980       if((1-beta2Exp[iS])==0) {
 981         Mass2[iS]=999.9;
 982         continue;
 983       }
 984       p2Exp[iS]=massOverZ[iS]*massOverZ[iS]*beta2Exp[iS]/(1-beta2Exp[iS]);
 985     }
 986     //--------------------for MC corrections
 987     if(p2Exp[iS]<0) {
 988       Mass2[iS]=999.9;
 989       continue;
 990     }
 991     pExp[iS]=TMath::Sqrt(p2Exp[iS]);
 992
 993     //------------
 994     Mass2[iS]=p2Exp[iS]*(1-beta*beta)/(beta*beta);
 995
 996     //-----------
 997     if(TMath::Abs(DCAxy)>DCAxyCut) continue;
 998     if(iS==2 || iS==3 || iS==4 || iS==5 || iS==7) {
 999       if((FlagPid & stdFlagPid[iS]) && (FlagPidTof & stdFlagPid[iS])) {
1000         if(charge>0) {
1001           if(iS!=7) prPmeanVsBGcorr[iBconf][iS-2]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
1002           else prPmeanVsBGcorr[iBconf][iS-3]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
1003         }
1004         else if(charge<0) {
1005           if(iS!=7) prPmeanVsBGcorr[iBconf][iS+3]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
1006           else prPmeanVsBGcorr[iBconf][iS+2]->Fill(pVtx[iS]/massOverZ[iS],pExp[iS]/pVtx[iS]);
1007         }
1008       }
1009     }
1010
1011   }//end loop on the particle species
1012
1013   return;
1014
1015 }
1016 //________________________________________________________________________________________
1017 void AliAnalysisNucleiMass::SetPmeanCorrections(){
1018
1019   //iMtof==8 -> different particle and antiparticle parameterization
1020
1021   Double_t pars_fPmeanVsBGcorr[nBconf][10][3];
1022   //particle
1023
1024   Double_t etaMin=0.0;
1025   Double_t etaMax=0.8;
1026
1027   if(EtaLimit[0]<0.0 || EtaLimit[1]<0.0) {
1028     etaMin=TMath::Abs(EtaLimit[1]);
1029     etaMax=TMath::Abs(EtaLimit[0]);
1030   }
1031   else {
1032     etaMin=TMath::Abs(EtaLimit[0]);
1033     etaMax=TMath::Abs(EtaLimit[1]);
1034   }
1035
1036   if(etaMin>-0.00001 && etaMax<0.10001) {
1037     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fAAA\n",EtaLimit[0],EtaLimit[1]);
1038     for(Int_t i=0;i<5;i++) {
1039       if(i==0) {//pi
1040         pars_fPmeanVsBGcorr[0][i][0]=4.16853e-02; pars_fPmeanVsBGcorr[0][i][1]=-7.67091e-01; pars_fPmeanVsBGcorr[0][i][2]=9.98035e-01;//B--
1041         pars_fPmeanVsBGcorr[1][i][0]=5.51380e-02; pars_fPmeanVsBGcorr[1][i][1]=-7.58112e-01; pars_fPmeanVsBGcorr[1][i][2]=1.00360e+00;//B++
1042       }
1043       else if(i==1) {//K
1044         pars_fPmeanVsBGcorr[0][i][0]=2.73697e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.43042e+00; pars_fPmeanVsBGcorr[0][i][2]=9.93148e-01;
1045         pars_fPmeanVsBGcorr[1][i][0]=3.19397e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.08037e+00; pars_fPmeanVsBGcorr[1][i][2]=9.98016e-01;
1046       }
1047       else if(i==2) {//p
1048         pars_fPmeanVsBGcorr[0][i][0]=1.35721e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.80958e+00; pars_fPmeanVsBGcorr[0][i][2]=9.93925e-01;
1049         pars_fPmeanVsBGcorr[1][i][0]=1.63564e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.55914e+00; pars_fPmeanVsBGcorr[1][i][2]=9.98106e-01;
1050       }
1051       else if(i==3) {//d
1052         pars_fPmeanVsBGcorr[0][i][0]=0.009609; pars_fPmeanVsBGcorr[0][i][1]=-2.534810; pars_fPmeanVsBGcorr[0][i][2]=0.993507;
1053         pars_fPmeanVsBGcorr[1][i][0]=0.011580; pars_fPmeanVsBGcorr[1][i][1]=-2.308857; pars_fPmeanVsBGcorr[1][i][2]=0.998126;
1054       }
1055       else if(i==4) {//He3
1056         pars_fPmeanVsBGcorr[0][i][0]=0.026420; pars_fPmeanVsBGcorr[0][i][1]=-2.253066; pars_fPmeanVsBGcorr[0][i][2]=0.993507;
1057         pars_fPmeanVsBGcorr[1][i][0]=0.031840; pars_fPmeanVsBGcorr[1][i][1]=-2.052228; pars_fPmeanVsBGcorr[1][i][2]=0.998126;
1058       }
1059     }
1060   }
1061   else if(etaMin>0.09999 && etaMax<0.20001) {
1062     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fBBB\n",EtaLimit[0],EtaLimit[1]);
1063     for(Int_t i=0;i<5;i++) {
1064       if(i==0) {//pi
1065         pars_fPmeanVsBGcorr[0][i][0]=4.98872e-02; pars_fPmeanVsBGcorr[0][i][1]=-3.56884e-01; pars_fPmeanVsBGcorr[0][i][2]=1.01356e+00;
1066         pars_fPmeanVsBGcorr[1][i][0]=6.11287e-02; pars_fPmeanVsBGcorr[1][i][1]=-3.65072e-01; pars_fPmeanVsBGcorr[1][i][2]=1.02074e+00;
1067       }
1068       else if(i==1) {//K
1069         pars_fPmeanVsBGcorr[0][i][0]=2.85027e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.04376e+00; pars_fPmeanVsBGcorr[0][i][2]=9.94804e-01;
1070         pars_fPmeanVsBGcorr[1][i][0]=3.30937e-02; pars_fPmeanVsBGcorr[1][i][1]=-1.72959e+00; pars_fPmeanVsBGcorr[1][i][2]=9.99966e-01;
1071       }
1072       else if(i==2) {//p
1073         pars_fPmeanVsBGcorr[0][i][0]=1.38640e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.71621e+00; pars_fPmeanVsBGcorr[0][i][2]=9.94151e-01;
1074         pars_fPmeanVsBGcorr[1][i][0]=1.74869e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.38269e+00; pars_fPmeanVsBGcorr[1][i][2]=9.98776e-01;
1075       }
1076       else if(i==3) {//d
1077         pars_fPmeanVsBGcorr[0][i][0]=0.009816; pars_fPmeanVsBGcorr[0][i][1]=-2.450567; pars_fPmeanVsBGcorr[0][i][2]=0.994465;
1078         pars_fPmeanVsBGcorr[1][i][0]=0.012381; pars_fPmeanVsBGcorr[1][i][1]=-2.149671; pars_fPmeanVsBGcorr[1][i][2]=0.999302;
1079       }
1080       else if(i==4) {//He3
1081         pars_fPmeanVsBGcorr[0][i][0]=0.026988; pars_fPmeanVsBGcorr[0][i][1]=-2.178186; pars_fPmeanVsBGcorr[0][i][2]=0.994465;
1082         pars_fPmeanVsBGcorr[1][i][0]=0.034041; pars_fPmeanVsBGcorr[1][i][1]=-1.910736; pars_fPmeanVsBGcorr[1][i][2]=0.999302;
1083       }
1084     }
1085   }
1086   else if(etaMin>0.19999 && etaMax<0.30001) {
1087     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fCCC\n",EtaLimit[0],EtaLimit[1]);
1088     for(Int_t i=0;i<5;i++) {
1089       if(i==0) {//pi
1090         pars_fPmeanVsBGcorr[0][i][0]=4.71844e-02; pars_fPmeanVsBGcorr[0][i][1]=-6.24048e-01; pars_fPmeanVsBGcorr[0][i][2]=1.00525e+00;
1091         pars_fPmeanVsBGcorr[1][i][0]=5.45281e-02; pars_fPmeanVsBGcorr[1][i][1]=-5.87331e-01; pars_fPmeanVsBGcorr[1][i][2]=1.01029e+00;
1092       }
1093       else if(i==1) {//K
1094         pars_fPmeanVsBGcorr[0][i][0]=2.92060e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.15537e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97130e-01;
1095         pars_fPmeanVsBGcorr[1][i][0]=3.24550e-02; pars_fPmeanVsBGcorr[1][i][1]=-1.97289e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00059e+00;
1096       }
1097       else if(i==2) {//p
1098         pars_fPmeanVsBGcorr[0][i][0]=1.33594e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.86707e+00; pars_fPmeanVsBGcorr[0][i][2]=9.96053e-01;
1099         pars_fPmeanVsBGcorr[1][i][0]=1.57187e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.62957e+00; pars_fPmeanVsBGcorr[1][i][2]=9.99431e-01;
1100       }
1101       else if(i==3) {//d
1102         pars_fPmeanVsBGcorr[0][i][0]=0.009458; pars_fPmeanVsBGcorr[0][i][1]=-2.586677; pars_fPmeanVsBGcorr[0][i][2]=0.996592;
1103         pars_fPmeanVsBGcorr[1][i][0]=0.011129; pars_fPmeanVsBGcorr[1][i][1]=-2.372404; pars_fPmeanVsBGcorr[1][i][2]=1.000024;
1104       }
1105       else if(i==4) {//He3
1106         pars_fPmeanVsBGcorr[0][i][0]=0.026006; pars_fPmeanVsBGcorr[0][i][1]=-2.299168; pars_fPmeanVsBGcorr[0][i][2]=0.996592;
1107         pars_fPmeanVsBGcorr[1][i][0]=0.030599; pars_fPmeanVsBGcorr[1][i][1]=-2.108711; pars_fPmeanVsBGcorr[1][i][2]=1.000024;
1108       }
1109     }
1110   }
1111   else if(etaMin>0.29999 && etaMax<0.40001) {
1112     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fDDD\n",EtaLimit[0],EtaLimit[1]);
1113     for(Int_t i=0;i<5;i++) {
1114       if(i==0) {//pi
1115         pars_fPmeanVsBGcorr[0][i][0]=5.25262e-02; pars_fPmeanVsBGcorr[0][i][1]=-3.04325e-01; pars_fPmeanVsBGcorr[0][i][2]=1.02056e+00;
1116         pars_fPmeanVsBGcorr[1][i][0]=5.70585e-02; pars_fPmeanVsBGcorr[1][i][1]=-5.95375e-01; pars_fPmeanVsBGcorr[1][i][2]=1.01130e+00;
1117       }
1118       else if(i==1) {//K
1119         pars_fPmeanVsBGcorr[0][i][0]=2.96035e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.17931e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97539e-01;
1120         pars_fPmeanVsBGcorr[1][i][0]=3.35067e-02; pars_fPmeanVsBGcorr[1][i][1]=-1.99656e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00128e+00;
1121       }
1122       else if(i==2) {//p
1123         pars_fPmeanVsBGcorr[0][i][0]=1.44529e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.77844e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97130e-01;
1124         pars_fPmeanVsBGcorr[1][i][0]=1.68180e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.56489e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00070e+00;
1125       }
1126       else if(i==3) {//d
1127         pars_fPmeanVsBGcorr[0][i][0]=0.010233; pars_fPmeanVsBGcorr[0][i][1]=-2.506714; pars_fPmeanVsBGcorr[0][i][2]=0.997341;
1128         pars_fPmeanVsBGcorr[1][i][0]=0.011907; pars_fPmeanVsBGcorr[1][i][1]=-2.314052; pars_fPmeanVsBGcorr[1][i][2]=1.001048;
1129       }
1130       else if(i==4) {//He3
1131         pars_fPmeanVsBGcorr[0][i][0]=0.028135; pars_fPmeanVsBGcorr[0][i][1]=-2.228093; pars_fPmeanVsBGcorr[0][i][2]=0.997341;
1132         pars_fPmeanVsBGcorr[1][i][0]=0.032739; pars_fPmeanVsBGcorr[1][i][1]=-2.056845; pars_fPmeanVsBGcorr[1][i][2]=1.001048;
1133       }
1134     }
1135   }
1136   else if(etaMin>0.39999 && etaMax<0.50001) {
1137     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fEEE\n",EtaLimit[0],EtaLimit[1]);
1138     for(Int_t i=0;i<5;i++) {
1139       if(i==0) {//pi
1140         pars_fPmeanVsBGcorr[0][i][0]=5.72833e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.51868e-01; pars_fPmeanVsBGcorr[0][i][2]=1.02665e+00;
1141         pars_fPmeanVsBGcorr[1][i][0]=6.59446e-02; pars_fPmeanVsBGcorr[1][i][1]=-9.09587e-01; pars_fPmeanVsBGcorr[1][i][2]=1.00472e+00;
1142       }
1143       else if(i==1) {//K
1144         pars_fPmeanVsBGcorr[0][i][0]=3.00754e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.18175e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97758e-01;
1145         pars_fPmeanVsBGcorr[1][i][0]=3.36764e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.08206e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00094e+00;
1146       }
1147       else if(i==2) {//p
1148         pars_fPmeanVsBGcorr[0][i][0]=1.54832e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.70549e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97921e-01;
1149         pars_fPmeanVsBGcorr[1][i][0]=1.75353e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.52898e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00121e+00;
1150       }
1151       else if(i==3) {//d
1152         pars_fPmeanVsBGcorr[0][i][0]=0.010962; pars_fPmeanVsBGcorr[0][i][1]=-2.440895; pars_fPmeanVsBGcorr[0][i][2]=0.997846;
1153         pars_fPmeanVsBGcorr[1][i][0]=0.012415; pars_fPmeanVsBGcorr[1][i][1]=-2.281648; pars_fPmeanVsBGcorr[1][i][2]=1.001189;
1154       }
1155       else if(i==4) {//He3
1156         pars_fPmeanVsBGcorr[0][i][0]=0.030140; pars_fPmeanVsBGcorr[0][i][1]=-2.169590; pars_fPmeanVsBGcorr[0][i][2]=0.997846;
1157         pars_fPmeanVsBGcorr[1][i][0]=0.034135; pars_fPmeanVsBGcorr[1][i][1]=-2.028043; pars_fPmeanVsBGcorr[1][i][2]=1.001189;
1158       }
1159     }
1160   }
1161   else if(etaMin>0.49999 && etaMax<0.60001) {
1162     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fFFF\n",EtaLimit[0],EtaLimit[1]);
1163     for(Int_t i=0;i<5;i++) {
1164       if(i==0) {//pi
1165         pars_fPmeanVsBGcorr[0][i][0]=5.29436e-02; pars_fPmeanVsBGcorr[0][i][1]=-5.04070e-01; pars_fPmeanVsBGcorr[0][i][2]=1.00951e+00;
1166         pars_fPmeanVsBGcorr[1][i][0]=1.04356e-01; pars_fPmeanVsBGcorr[1][i][1]=-1.19297e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00197e+00;
1167       }
1168       else if(i==1) {//K
1169         pars_fPmeanVsBGcorr[0][i][0]=3.36237e-02; pars_fPmeanVsBGcorr[0][i][1]=-1.89739e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97921e-01;
1170         pars_fPmeanVsBGcorr[1][i][0]=3.76386e-02; pars_fPmeanVsBGcorr[1][i][1]=-1.89484e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00097e+00;
1171       }
1172       else if(i==2) {//p
1173         pars_fPmeanVsBGcorr[0][i][0]=1.93889e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.38744e+00; pars_fPmeanVsBGcorr[0][i][2]=9.98551e-01;
1174         pars_fPmeanVsBGcorr[1][i][0]=2.12666e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.29606e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00174e+00;
1175       }
1176       else if(i==3) {//d
1177         pars_fPmeanVsBGcorr[0][i][0]=0.013727; pars_fPmeanVsBGcorr[0][i][1]=-2.153951; pars_fPmeanVsBGcorr[0][i][2]=0.998275;
1178         pars_fPmeanVsBGcorr[1][i][0]=0.015057; pars_fPmeanVsBGcorr[1][i][1]=-2.071511; pars_fPmeanVsBGcorr[1][i][2]=1.001396;
1179       }
1180       else if(i==4) {//He3
1181         pars_fPmeanVsBGcorr[0][i][0]=0.037743; pars_fPmeanVsBGcorr[0][i][1]=-1.914539; pars_fPmeanVsBGcorr[0][i][2]=0.998275;
1182         pars_fPmeanVsBGcorr[1][i][0]=0.041398; pars_fPmeanVsBGcorr[1][i][1]=-1.841262; pars_fPmeanVsBGcorr[1][i][2]=1.001396;
1183       }
1184     }
1185   }
1186   else if(etaMin>0.59999 && etaMax<0.70001) {
1187     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fGGG\n",EtaLimit[0],EtaLimit[1]);
1188     for(Int_t i=0;i<5;i++) {
1189       if(i==0) {//pi
1190         pars_fPmeanVsBGcorr[0][i][0]=7.18462e-02; pars_fPmeanVsBGcorr[0][i][1]=-1.15676e+00; pars_fPmeanVsBGcorr[0][i][2]=9.99111e-01;
1191         pars_fPmeanVsBGcorr[1][i][0]=8.52428e-02; pars_fPmeanVsBGcorr[1][i][1]=-9.11048e-01; pars_fPmeanVsBGcorr[1][i][2]=1.00777e+00;
1192       }
1193       else if(i==1) {//K
1194         pars_fPmeanVsBGcorr[0][i][0]=3.32328e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.30015e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97683e-01;
1195         pars_fPmeanVsBGcorr[1][i][0]=3.88555e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.18109e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00130e+00;
1196       }
1197       else if(i==2) {//p
1198         pars_fPmeanVsBGcorr[0][i][0]=1.71488e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.73349e+00; pars_fPmeanVsBGcorr[0][i][2]=9.98517e-01;
1199         pars_fPmeanVsBGcorr[1][i][0]=1.89105e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.65564e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00159e+00;
1200       }
1201       else if(i==3) {//d
1202         pars_fPmeanVsBGcorr[0][i][0]=0.012141; pars_fPmeanVsBGcorr[0][i][1]=-2.466162; pars_fPmeanVsBGcorr[0][i][2]=0.998125;
1203         pars_fPmeanVsBGcorr[1][i][0]=0.013389; pars_fPmeanVsBGcorr[1][i][1]=-2.395927; pars_fPmeanVsBGcorr[1][i][2]=1.001633;
1204       }
1205       else if(i==4) {//He3
1206         pars_fPmeanVsBGcorr[0][i][0]=0.033383; pars_fPmeanVsBGcorr[0][i][1]=-2.192048; pars_fPmeanVsBGcorr[0][i][2]=0.998125;
1207         pars_fPmeanVsBGcorr[1][i][0]=0.036812; pars_fPmeanVsBGcorr[1][i][1]=-2.129620; pars_fPmeanVsBGcorr[1][i][2]=1.001633;
1208       }
1209     }
1210   }
1211   else if(etaMin>0.69999 && etaMax<0.80001) {
1212     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fHHH\n",EtaLimit[0],EtaLimit[1]);
1213     for(Int_t i=0;i<5;i++) {
1214       if(i==0) {//pi
1215         pars_fPmeanVsBGcorr[0][i][0]=9.56419e-02; pars_fPmeanVsBGcorr[0][i][1]=-1.31941e+00; pars_fPmeanVsBGcorr[0][i][2]=9.98375e-01;
1216         pars_fPmeanVsBGcorr[1][i][0]=8.30340e-02; pars_fPmeanVsBGcorr[1][i][1]=-4.46775e-01; pars_fPmeanVsBGcorr[1][i][2]=1.02721e+00;
1217       }
1218       else if(i==1) {//K
1219         pars_fPmeanVsBGcorr[0][i][0]=3.55532e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.25782e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97746e-01;
1220         pars_fPmeanVsBGcorr[1][i][0]=4.26998e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.10431e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00185e+00;
1221       }
1222       else if(i==2) {//p
1223         pars_fPmeanVsBGcorr[0][i][0]=1.87103e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.65814e+00; pars_fPmeanVsBGcorr[0][i][2]=9.98847e-01;
1224         pars_fPmeanVsBGcorr[1][i][0]=2.07010e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.60124e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00210e+00;
1225       }
1226       else if(i==3) {//d
1227         pars_fPmeanVsBGcorr[0][i][0]=0.013247; pars_fPmeanVsBGcorr[0][i][1]=-2.398177; pars_fPmeanVsBGcorr[0][i][2]=0.998269;
1228         pars_fPmeanVsBGcorr[1][i][0]=0.014656; pars_fPmeanVsBGcorr[1][i][1]=-2.346847; pars_fPmeanVsBGcorr[1][i][2]=1.002033;
1229       }
1230       else if(i==4) {//He3
1231         pars_fPmeanVsBGcorr[0][i][0]=0.036422; pars_fPmeanVsBGcorr[0][i][1]=-2.131620; pars_fPmeanVsBGcorr[0][i][2]=0.998269;
1232         pars_fPmeanVsBGcorr[1][i][0]=0.040298; pars_fPmeanVsBGcorr[1][i][1]=-2.085995; pars_fPmeanVsBGcorr[1][i][2]=1.002033;
1233       }
1234     }
1235   }
1236   else {//for all eta
1237     //printf("EtaLimit[0]== %f and EtaLimit[1]== %fIII\n",EtaLimit[0],EtaLimit[1]);
1238     for(Int_t i=0;i<5;i++) {
1239       if(i==0) {//pi
1240         pars_fPmeanVsBGcorr[0][i][0]=4.89956e-02; pars_fPmeanVsBGcorr[0][i][1]=-6.46308e-01; pars_fPmeanVsBGcorr[0][i][2]=1.00462e+00;
1241         pars_fPmeanVsBGcorr[1][i][0]=6.36672e-02; pars_fPmeanVsBGcorr[1][i][1]=-6.10966e-01; pars_fPmeanVsBGcorr[1][i][2]=1.01188e+00;
1242       }
1243       else if(i==1) {//K
1244         pars_fPmeanVsBGcorr[0][i][0]=3.06216e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.10247e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97142e-01;
1245         pars_fPmeanVsBGcorr[1][i][0]=3.48865e-02; pars_fPmeanVsBGcorr[1][i][1]=-1.89213e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00123e+00;
1246       }
1247       else if(i==2) {//p
1248         pars_fPmeanVsBGcorr[0][i][0]=1.58652e-02; pars_fPmeanVsBGcorr[0][i][1]=-2.64898e+00; pars_fPmeanVsBGcorr[0][i][2]=9.97176e-01;
1249         pars_fPmeanVsBGcorr[1][i][0]=1.83264e-02; pars_fPmeanVsBGcorr[1][i][1]=-2.45858e+00; pars_fPmeanVsBGcorr[1][i][2]=1.00079e+00;
1250       }
1251       else if(i==3) {//d
1252         pars_fPmeanVsBGcorr[0][i][0]=0.011233; pars_fPmeanVsBGcorr[0][i][1]=-2.389911; pars_fPmeanVsBGcorr[0][i][2]=0.997176;//0.997210
1253         pars_fPmeanVsBGcorr[1][i][0]=0.012975; pars_fPmeanVsBGcorr[1][i][1]=-2.218137; pars_fPmeanVsBGcorr[1][i][2]=1.001091;
1254       }
1255       else if(i==4) {//He3
1256         pars_fPmeanVsBGcorr[0][i][0]=0.030884; pars_fPmeanVsBGcorr[0][i][1]=-2.124273; pars_fPmeanVsBGcorr[0][i][2]=0.997176;//0.997210
1257         pars_fPmeanVsBGcorr[1][i][0]=0.035675; pars_fPmeanVsBGcorr[1][i][1]=-1.971591; pars_fPmeanVsBGcorr[1][i][2]=1.001091;
1258       }
1259     }
1260   }
1261
1262   /*
1263   for(Int_t iB=0;iB<nBconf;iB++) {
1264     for(Int_t i=0;i<5;i++) {
1265       pars_fPmeanVsBGcorr[iB][i][0]=0.02; pars_fPmeanVsBGcorr[iB][i][1]=-2.0; pars_fPmeanVsBGcorr[iB][i][2]=1.0;
1266     }
1267     }*/
1268
1269   for(Int_t iB=0;iB<nBconf;iB++) {
1270     for(Int_t i=5;i<10;i++) {
1271       pars_fPmeanVsBGcorr[iB][i][0]=pars_fPmeanVsBGcorr[iB][i-5][0];
1272       pars_fPmeanVsBGcorr[iB][i][1]=pars_fPmeanVsBGcorr[iB][i-5][1];
1273       pars_fPmeanVsBGcorr[iB][i][2]=pars_fPmeanVsBGcorr[iB][i-5][2];
1274     }
1275   }
1276
1277   for(Int_t iB=0;iB<nBconf;iB++) {
1278     for(Int_t i=0;i<10;i++) {
1279       fPmeanVsBGcorr[iB][i]->SetParameters(pars_fPmeanVsBGcorr[iB][i]);
1280       fPmeanVsBGcorr[iB][i]->SetNpx(fPmeanVsBGcorr[iB][i]->GetNpx()*10);
1281     }
1282   }
1283
1284   return;
1285
1286 }
1287