PWGLF/SPECTRA/Nuclei/masses/AliAnalysisNucleiInfo.cxx

   1 #include "AliAnalysisNucleiInfo.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 "TH1I.h"
  19 #include "TF1.h"
  20 #include "TF2.h"
  21 #include "TGraph.h"
  22 #include "TProfile.h"
  23 #include "AliESDtrackCuts.h"
  24 #include "AliAnalysisManager.h"
  25 #include "TFile.h"
  26
  27 ClassImp(AliAnalysisNucleiInfo)
  28
  29 //_____________________________________________________________________________
  30 AliAnalysisNucleiInfo::AliAnalysisNucleiInfo():
  31   AliAnalysisTaskSE(),
  32   FilterBit(16),
  33   EtaLimit(),
  34   DCAxyCut(1000.),
  35   DCAzCut(1000.),
  36   NsigmaTpcCut(2.0),
  37   StartTimeTofRes(9999.9),
  38   iBconf(0),
  39   kTOF(0),
  40 //iTriggerSel(-99),
  41   fAOD(NULL),
  42   fESD(NULL),
  43   fEvent(NULL),
  44   fPIDResponse(NULL)
  45 {
  46   EtaLimit[0]=-99.0;
  47   EtaLimit[1]=99.0;
  48
  49   fList[0]=new TList();
  50   fList[0]->SetName("results");
  51
  52   fList[1]=new TList();
  53   fList[1]->SetName("results2");
  54 }
  55 //______________________________________________________________________________
  56 AliAnalysisNucleiInfo::AliAnalysisNucleiInfo(const char *name):
  57   AliAnalysisTaskSE(name),
  58   FilterBit(16),
  59   EtaLimit(),
  60   DCAxyCut(1000.),
  61   DCAzCut(1000.),
  62   NsigmaTpcCut(2.0),
  63   StartTimeTofRes(9999.9),
  64   iBconf(0),
  65   kTOF(0),
  66   //iTriggerSel(-99),
  67   fAOD(NULL),
  68   fESD(NULL),
  69   fEvent(NULL),
  70   fPIDResponse(NULL)
  71 {
  72
  73   EtaLimit[0]=-99.0;
  74   EtaLimit[1]=99.0;
  75
  76   fList[0]=new TList();
  77   DefineOutput(1, TList::Class());
  78   fList[0]->SetName("results");
  79
  80   fList[1]=new TList();
  81   DefineOutput(2, TList::Class());
  82   fList[1]->SetName("results2");
  83 }
  84 //_____________________________________________________________________________
  85 AliAnalysisNucleiInfo::~AliAnalysisNucleiInfo()
  86 {
  87   if(fList[0]) delete fList[0];
  88   if(fList[1]) delete fList[1];
  89 }
  90 //______________________________________________________________________________
  91 void AliAnalysisNucleiInfo::UserCreateOutputObjects()
  92 {
  93   Char_t namePart[nPart][30];
  94   snprintf(namePart[0],30,"e");
  95   snprintf(namePart[1],30,"mu");
  96   snprintf(namePart[2],30,"pi");
  97   snprintf(namePart[3],30,"K");
  98   snprintf(namePart[4],30,"p");
  99   snprintf(namePart[5],30,"d");
 100   snprintf(namePart[6],30,"t");
 101   snprintf(namePart[7],30,"He3");
 102   snprintf(namePart[8],30,"He4");
 103
 104   Char_t name[nSpec][30];
 105   snprintf(name[0],20,"e_plus");
 106   snprintf(name[1],20,"mu_plus");
 107   snprintf(name[2],20,"pi_plus");
 108   snprintf(name[3],20,"K_plus");
 109   snprintf(name[4],20,"p");
 110   snprintf(name[5],20,"d");
 111   snprintf(name[6],20,"t");
 112   snprintf(name[7],20,"He3");
 113   snprintf(name[8],20,"He4");
 114   snprintf(name[9],20,"e_minus");
 115   snprintf(name[10],20,"mu_minus");
 116   snprintf(name[11],20,"pi_minus");
 117   snprintf(name[12],20,"K_minus");
 118   snprintf(name[13],20,"p_bar");
 119   snprintf(name[14],20,"d_bar");
 120   snprintf(name[15],20,"t_bar");
 121   snprintf(name[16],20,"He3_bar");
 122   snprintf(name[17],20,"He4_bar");
 123
 124   Int_t hbins[2];
 125
 126   for(Int_t iB=0;iB<nBconf;iB++) {
 127
 128     htemp[iB] = new TH1F("htemp","htemp (avoid the problem with the empty list...);B field",20,-10,10);
 129
 130     //htriggerbits[iB] = new TH1I("htriggerbits","htriggerbits; bits",10,-5,5);
 131     htriggerbits[iB][0] = new TH1I("htriggerbits_0","trigger mask; bits",45,-5,40);
 132     htriggerbits[iB][1] = new TH1I("htriggerbits_1","trigger bits (exclusive); bits",45,-5,40);
 133
 134     hZvertex[iB][0] = new TH1F("hZvertex_Selected","Vertex distribution of selected events;z vertex (cm)",240,-30,30);
 135     hZvertex[iB][1] = new TH1F("hZvertex_Analyzed","Vertex distribution of analyzed events;z vertex (cm)",240,-30,30);
 136
 137     hEta[iB] = new TH1F("hEta_Analyzed","|#eta| distribution after the track cuts;#eta",200,-1.0,1.0);
 138
 139     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)
 140
 141     hNtrackAtTof[iB] = new TH1I("hNtrackAtTof","num. tracks when kTOF is required; Number of tracks",3000,0,3000);
 142
 143     hStartTimeRes[iB] = new TH1F("hStartTimeRes","hStartTimeRes;t_{0} (ps)",500,0,500);
 144
 145     //hbins[0]=500; hbins[1]=2000;
 146     hbins[0]=500; hbins[1]=2000;//hbins[0]=100; hbins[1]=500
 147     fdEdxVSp[iB][0] = new TH2F("fdEdxVSp_pos","dE/dx vs p (positive charge); p_{TPC}/z (GeV/c); dE/dx_{TPC} (a.u.)",hbins[0],0,10,hbins[1],0,1000);
 148     fdEdxVSp[iB][1] = new TH2F("fdEdxVSp_neg","dE/dx vs p (negative charge); p_{TPC}/z (GeV/c); dE/dx_{TPC} (a.u.)",hbins[0],0,10,hbins[1],0,1000);
 149
 150     Char_t name_hDeDxExp[nPart][200];
 151     Char_t title_hDeDxExp[nPart][200];
 152     for(Int_t i=0;i<nPart;i++) {
 153       snprintf(name_hDeDxExp[i],200,"hDeDxExp_%s",namePart[i]);
 154       snprintf(title_hDeDxExp[i],200,"Expected dE/dx of %s in the TPC;p_{TPC}/z (GeV/c);dE/dx_{TPC} (a.u.)",namePart[i]);
 155       hDeDxExp[iB][i] = new TProfile(name_hDeDxExp[i],title_hDeDxExp[i],200,0,10,0,1000,"");//,500,0,5,0,1000,""); toram
 156     }
 157
 158     Char_t name_fNsigmaTpc[nSpec][200];
 159     Char_t title_fNsigmaTpc[nSpec][200];
 160     hbins[0]=200; hbins[1]=200;
 161     for(Int_t i=0;i<nSpec;i++) {
 162       snprintf(name_fNsigmaTpc[i],200,"NsigmaTpc_%s",name[i]);
 163       snprintf(title_fNsigmaTpc[i],200,"NsigmaTpc_%s;p_{TPC}/z (GeV/c);n_{#sigma_{TPC}}^{%s}",name[i],name[i]);
 164       fNsigmaTpc[iB][i] = new TH2F(name_fNsigmaTpc[i],title_fNsigmaTpc[i],hbins[0],0,10,hbins[1],-10,10);
 165     }
 166
 167     hbins[0]=500; hbins[1]=520;//hbins[0]=200; hbins[1]=260;
 168     fBetaTofVSp[iB][0] = new TH2F("fBetaTofVSp_pos","#beta_{TOF} vs p/z (positive charge);p(GeV/c);#beta_{TOF}",hbins[0],0,10,hbins[1],0.4,1.05);
 169     fBetaTofVSp[iB][1] = new TH2F("fBetaTofVSp_neg","#beta_{TOF} vs p/z (negative charge);p(GeV/c);#beta_{TOF}",hbins[0],0,10,hbins[1],0.4,1.05);
 170
 171     Char_t name_hBetaExp[nPart][200];
 172     Char_t title_hBetaExp[nPart][200];
 173     for(Int_t i=0;i<nPart;i++) {
 174       snprintf(name_hBetaExp[i],200,"hBetaTofVsP_Exp_%s",namePart[i]);
 175       snprintf(title_hBetaExp[i],200,"Expected #beta_{TOF} vs p/z of %s;p/z (GeV/c); #beta_{TOF}",namePart[i]);
 176       hBetaExp[iB][i] = new TProfile(name_hBetaExp[i],title_hBetaExp[i],200,0,10,0.4,1.05,"");
 177     }
 178
 179     Char_t name_fNsigmaTof[2][nSpec][200];
 180     Char_t title_fNsigmaTof[2][nSpec][200];
 181     hbins[0]=200; hbins[1]=2000;//hbins[0]=200; hbins[1]=200;
 182     for(Int_t i=0;i<nSpec;i++) {
 183       snprintf(name_fNsigmaTof[0][i],200,"NsigmaTof_%s",name[i]);
 184       snprintf(title_fNsigmaTof[0][i],200,"NsigmaTof_%s;p_{T}/z (GeV/c);n_{#sigma_{TOF}}^{%s}",name[i],name[i]);
 185
 186       snprintf(name_fNsigmaTof[1][i],200,"NsigmaTofWtpc_%s",name[i]);
 187       snprintf(title_fNsigmaTof[1][i],200,"NsigmaTofWtpc_%s (with a 2#sigma TPC cut);p_{T}/z (GeV/c);n_{#sigma_{TOF}}^{%s}",name[i],name[i]);
 188     }
 189     for(Int_t it=0;it<2;it++) {
 190       for(Int_t i=0;i<nSpec;i++) {
 191         fNsigmaTof[iB][it][i] = new TH2F(name_fNsigmaTof[it][i],title_fNsigmaTof[it][i],hbins[0],0,10,hbins[1],-100,100);//,hbins[0],0,10,hbins[1],-10,10
 192       }
 193     }
 194
 195
 196     Char_t name_fTofMinusExp[2][nSpec][200];
 197     Char_t title_fTofMinusExp[2][nSpec][200];
 198     hbins[0]=200; hbins[1]=2000;
 199
 200     for(Int_t i=0;i<nSpec;i++) {
 201       snprintf(name_fTofMinusExp[0][i],200,"TofMinusExp_%s",name[i]);
 202       snprintf(title_fTofMinusExp[0][i],200,"TofMinusExp_%s;p_{T}/z (GeV/c);tof-t_{exp}^{%s} (ps)",name[i],name[i]);
 203
 204       snprintf(name_fTofMinusExp[1][i],200,"TofMinusExpWtpc_%s",name[i]);
 205       snprintf(title_fTofMinusExp[1][i],200,"TofMinusExpWtpc_%s (with a 2#sigma TPC cut);p_{T}/z (GeV/c);tof-t_{exp}^{%s} (ps)",name[i],name[i]);
 206     }
 207     for(Int_t it=0;it<2;it++) {
 208       for(Int_t i=0;i<nSpec;i++) {
 209         fTofMinusExp[iB][it][i] = new TH2F(name_fTofMinusExp[it][i],title_fTofMinusExp[it][i],hbins[0],0,10,hbins[1],-20000,20000);
 210       }
 211     }
 212
 213     Char_t name_h2DCAap[18][200];
 214     Char_t title_h2DCAap[18][200];
 215
 216     for(Int_t iS=0;iS<nSpec;iS++) {
 217       snprintf(name_h2DCAap[iS],200,"h2DCAap_%s",name[iS]);
 218       snprintf(title_h2DCAap[iS],200,"h2DCA_%s in for p_{T}/z<1.5GeV/c;DCA_{xy} (cm);DCA_{z} (cm)",name[iS]);
 219       if(iS==5 || iS==5+9) h2DCAap[iB][iS] = new TH2F(name_h2DCAap[iS],title_h2DCAap[iS],1750,-3.5,3.5,1750,-3.5,3.5);
 220       else h2DCAap[iB][iS] = new TH2F(name_h2DCAap[iS],title_h2DCAap[iS],1,-3.5,3.5,1,-3.5,3.5);
 221     }
 222
 223     fList[iB]->Add(htemp[iB]);
 224     for(Int_t i=0;i<2;i++) fList[iB]->Add(htriggerbits[iB][i]);
 225     for(Int_t i=0;i<2;i++) fList[iB]->Add(hZvertex[iB][i]);
 226     fList[iB]->Add(hEta[iB]);
 227     fList[iB]->Add(hPhi[iB]);
 228     for(Int_t i=0;i<2;i++) fList[iB]->Add(fdEdxVSp[iB][i]);
 229     for(Int_t i=0;i<nPart;i++) {
 230       fList[iB]->Add(hDeDxExp[iB][i]);
 231     }
 232     for(Int_t i=0;i<nSpec;i++) {
 233       fList[iB]->Add(fNsigmaTpc[iB][i]);
 234     }
 235     for(Int_t i=0;i<2;i++) fList[iB]->Add(fBetaTofVSp[iB][i]);
 236     for(Int_t i=0;i<nPart;i++) {
 237       fList[iB]->Add(hBetaExp[iB][i]);
 238     }
 239     fList[iB]->Add(hNtrackAtTof[iB]);
 240     fList[iB]->Add(hStartTimeRes[iB]);
 241     for(Int_t i=0;i<nSpec;i++) {
 242       fList[iB]->Add(fNsigmaTof[iB][0][i]);
 243     }
 244     for(Int_t i=0;i<nSpec;i++) {
 245       fList[iB]->Add(fNsigmaTof[iB][1][i]);
 246     }
 247     for(Int_t i=0;i<nSpec;i++) {
 248       fList[iB]->Add(fTofMinusExp[iB][0][i]);
 249     }
 250     for(Int_t i=0;i<nSpec;i++) {
 251       fList[iB]->Add(fTofMinusExp[iB][1][i]);
 252     }
 253     for(Int_t iS=0;iS<nSpec;iS++) {
 254       if(iS==5 || iS==5+9) fList[iB]->Add(h2DCAap[iB][iS]);
 255     }
 256
 257     // Post output data.
 258     PostData(1, fList[0]);
 259     PostData(2, fList[1]);
 260
 261   }//end iB loop
 262 }
 263 //______________________________________________________________________________
 264 void AliAnalysisNucleiInfo::UserExec(Option_t *)
 265 {
 266   // Main loop
 267   // Called for each event
 268
 269   fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
 270   fESD = dynamic_cast<AliESDEvent*>(InputEvent());
 271   if(!fAOD && !fESD){
 272     Printf("%s:%d AODEvent and ESDEvent not found in Input Manager",(char*)__FILE__,__LINE__);
 273     return;
 274   }
 275
 276   if(fESD) fEvent = fESD;
 277   else fEvent = fAOD;
 278
 279   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 280   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 281   fPIDResponse=inputHandler->GetPIDResponse();
 282
 283   //--------------------------Magnetic field polarity--------------------
 284   Double_t fBfield=fEvent->GetMagneticField();
 285   if(fBfield<0.0) iBconf=0;//B--
 286   else iBconf=1;//B++
 287   for(Int_t i=0;i<nBconf;i++) htemp[i]->Fill(fBfield);
 288
 289   //-------------------------zVertex determination of event----------------
 290   Double_t zvtx = 9999.9;
 291   const AliVVertex* vtxEVENT = fEvent->GetPrimaryVertex();
 292   if(vtxEVENT->GetNContributors()>0) zvtx = vtxEVENT->GetZ();
 293
 294   hZvertex[iBconf][0]->Fill(zvtx);
 295
 296   //---------------------------EVENT CUTS-----------------------------
 297   if(TMath::Abs(zvtx) < 10.0){
 298
 299     //TRIGGER SELECTION
 300     Int_t iTrigger=-2;
 301
 302     if(inputHandler->IsEventSelected() & AliVEvent::kMB) iTrigger = 0;
 303     if(inputHandler->IsEventSelected() & AliVEvent::kCentral) iTrigger = 16;
 304     if(inputHandler->IsEventSelected() & AliVEvent::kSemiCentral) iTrigger = 17;
 305     //if((((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()) & AliVEvent::kAny) iTrigger = 35;
 306
 307     if(iTriggerSel!=-99) {//if a dedicated trigger is required
 308       if(iTrigger!=iTriggerSel) return;
 309     }
 310
 311     for(Int_t i=0;i<32;i++) {
 312       Int_t bit=(1<<i);
 313       if(inputHandler->IsEventSelected() & bit) htriggerbits[iBconf][0]->Fill(i);
 314     }
 315     if(inputHandler->IsEventSelected() & AliVEvent::kAny) htriggerbits[iBconf][0]->Fill(35);
 316     if(inputHandler->IsEventSelected() & AliVEvent::kAnyINT) htriggerbits[iBconf][0]->Fill(36);
 317
 318     htriggerbits[iBconf][1]->Fill(iTrigger);
 319
 320     hZvertex[iBconf][1]->Fill(zvtx);
 321
 322     Int_t nTracks = fEvent->GetNumberOfTracks();
 323
 324     //----------------------loop on the TRACKS-----------------------------
 325     for(Int_t iT = 0; iT < nTracks; iT++) {
 326       AliVTrack* track = (AliVTrack *) fEvent->GetTrack(iT);
 327
 328       if (!track){
 329         continue;
 330       }
 331
 332      //For the geometrical cuts
 333       Double_t eta = track->Eta();
 334
 335       Bool_t trkFlag = 0;
 336       trkFlag = ((AliAODTrack *) track)->TestFilterBit(FilterBit);
 337       //TestFilterBit(16) -- Standard Cuts with very loose DCA: GetStandardITSTPCTrackCuts2011(kFALSE) && SetMaxDCAToVertexXY(2.4) && SetMaxDCAToVertexZ(3.2) && SetDCaToVertex2D(kTRUE)
 338       //TestFilterBit(32) (STARDARD) -- Standard Cuts with very tight DCA cut ( 7sigma^primaries: 7*(0.0015+0.0050/pt^1.1) ) : GetStandardITSTPCTrackCuts2011().
 339
 340       //-------------------------------------start TRACK CUTS--------------------------------
 341       if ((track->Pt() < 0.2) || (eta<EtaLimit[0]) || (eta>EtaLimit[1]) || !trkFlag)
 342         continue;
 343
 344        //Vertex determination
 345       Double_t b[2] = {-99., -99.};
 346       Double_t bCov[3] = {-99., -99., -99.};
 347       if (!track->PropagateToDCA(fEvent->GetPrimaryVertex(), fEvent->GetMagneticField(), 100., b, bCov))
 348         continue;
 349
 350       Double_t DCAxy = b[0];
 351       Double_t DCAz = b[1];
 352
 353       //Cut on the DCAxy
 354       Bool_t isDCAxyCut=kFALSE;
 355       if(TMath::Abs(DCAxy)<DCAxyCut) isDCAxyCut=kTRUE;
 356
 357       //Cut on the DCAz
 358       Bool_t isDCAzCut=kFALSE;
 359       if(TMath::Abs(DCAz)<DCAzCut) isDCAzCut=kTRUE;
 360
 361       if (!isDCAxyCut || !isDCAzCut)
 362         continue;
 363
 364       //-------------------------------------end TRACK CUTS----------------------------------
 365
 366       //-------------------------------------Track info--------------------------------------
 367       Double_t phi= track->Phi();
 368       Double_t charge = (Double_t)track->Charge();
 369       Double_t p = track->P();
 370       Double_t pt = track->Pt();
 371       Double_t dedx = track->GetTPCsignal();
 372       Double_t pTPC = track->GetTPCmomentum();
 373       Double_t tof  = track->GetTOFsignal()-fPIDResponse->GetTOFResponse().GetStartTime(p);
 374       Double_t beta = 0.0;
 375       //Double_t M2 = 999.9;
 376       //Double_t Z2 = 999.9;
 377
 378       kTOF = (track->GetStatus() & AliVTrack::kTOFout) && (track->GetStatus() & AliVTrack::kTIME);
 379
 380       //-----------------------------TPC info------------------------------
 381       Double_t nsigmaTPC[nPart];
 382       Double_t expdedx[nPart];
 383
 384       Int_t stdFlagPid[9] = {1,2,4,8,16,32,64,128,256};//e,mu,pi,K,p,d,t,He3,He4
 385       Int_t FlagPid = 0;
 386
 387       for(Int_t iS=0;iS<9;iS++){
 388         nsigmaTPC[iS] = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType) iS);
 389         //TPC identification:
 390         if(TMath::Abs(nsigmaTPC[iS])<NsigmaTpcCut) {
 391           FlagPid += ((Int_t)TMath::Power(2,iS));
 392         }
 393       }
 394
 395       hEta[iBconf]->Fill(eta);
 396       hPhi[iBconf]->Fill(phi);
 397
 398       //More TPC info:
 399       for(Int_t iS=0;iS<9;iS++){
 400         expdedx[iS] = fPIDResponse->GetTPCResponse().GetExpectedSignal(track, (AliPID::EParticleType) iS, AliTPCPIDResponse::kdEdxDefault, kTRUE);
 401         hDeDxExp[iBconf][iS]->Fill(pTPC,expdedx[iS]);
 402         nsigmaTPC[iS] = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType) iS);
 403         //fNsigmaTpc[iBconf][iS]->Fill(pTPC,nsigmaTPC[iS]);
 404         if(charge>0) {//positive particle
 405           fNsigmaTpc[iBconf][iS]->Fill(pTPC,nsigmaTPC[iS]);
 406         }
 407         else {//negative particle
 408           fNsigmaTpc[iBconf][iS+nPart]->Fill(pTPC,nsigmaTPC[iS]);
 409         }
 410       }
 411
 412       if(charge>0) fdEdxVSp[iBconf][0]->Fill(pTPC,dedx);
 413       else fdEdxVSp[iBconf][1]->Fill(pTPC,dedx);
 414
 415       //ITS info
 416       for(Int_t iS=0;iS<9;iS++){
 417         if(FlagPid & stdFlagPid[iS]) {
 418           if(pt<1.5) {
 419             if(charge>0) {
 420               h2DCAap[iBconf][iS]->Fill(DCAxy,DCAz);
 421               h2DCAap[iBconf][iS]->Fill(-DCAxy,-DCAz);
 422             }
 423             else {
 424               h2DCAap[iBconf][iS+nPart]->Fill(DCAxy,DCAz);
 425               h2DCAap[iBconf][iS+nPart]->Fill(-DCAxy,-DCAz);
 426             }
 427           }
 428         }
 429       }
 430
 431       //-----------------------------TOF info------------------------------
 432
 433       Double_t massOverZ[9] = {0.000511,0.105658,0.139570,0.493677,0.938272,1.875612859,2.808921005,1.404195741,1.863689620};
 434
 435       //----------------------------------------kTOF available-----------------------------
 436
 437       if(kTOF) {
 438
 439         Float_t startTimeRes = -9.9;
 440         startTimeRes = fPIDResponse->GetTOFResponse().GetStartTimeRes(p);
 441
 442         if(startTimeRes>StartTimeTofRes) continue;
 443
 444         hStartTimeRes[iBconf]->Fill(startTimeRes);
 445         hNtrackAtTof[iBconf]->Fill(nTracks);
 446
 447         Double_t exptimes[9];
 448         track->GetIntegratedTimes(exptimes);
 449         //Integrated times of the Nuclei:
 450         for(Int_t iN=5;iN<9;iN++) {
 451           exptimes[iN] = exptimes[4]*exptimes[4]*(massOverZ[iN]*massOverZ[iN]/p/p+1)/(massOverZ[4]*massOverZ[4]/p/p+1);
 452           exptimes[iN] = TMath::Sqrt(exptimes[iN]);
 453         }
 454
 455         beta=exptimes[0];
 456         beta=beta/tof;//beta = L/tof/c = t_e/tof
 457
 458         Double_t nsigmaTOF[9];
 459         for(Int_t iS=0;iS<9;iS++){
 460           nsigmaTOF[iS] = fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType) iS);
 461           if(charge>0) {
 462             hBetaExp[iBconf][iS]->Fill(p,exptimes[0]/exptimes[iS]);
 463             fNsigmaTof[iBconf][0][iS]->Fill(pt,nsigmaTOF[iS]);
 464           }
 465           else {
 466             hBetaExp[iBconf][iS+nPart]->Fill(p,exptimes[0]/exptimes[iS]);
 467             fNsigmaTof[iBconf][0][iS+nPart]->Fill(pt,nsigmaTOF[iS]);
 468           }
 469         }
 470
 471         if(charge>0) fBetaTofVSp[iBconf][0]->Fill(p,beta);
 472         else fBetaTofVSp[iBconf][1]->Fill(p,beta);
 473
 474         for(Int_t iS=0;iS<9;iS++){
 475           if(charge>0) {
 476             fTofMinusExp[iBconf][0][iS]->Fill(pt,tof-exptimes[iS]);
 477             if(FlagPid & stdFlagPid[iS]) {
 478               fTofMinusExp[iBconf][1][iS]->Fill(pt,tof-exptimes[iS]);
 479               fNsigmaTof[iBconf][1][iS]->Fill(pt,nsigmaTOF[iS]);
 480             }
 481           }
 482           else {
 483             fTofMinusExp[iBconf][0][iS+nPart]->Fill(pt,tof-exptimes[iS]);
 484             if(FlagPid & stdFlagPid[iS]) {
 485               fTofMinusExp[iBconf][1][iS+nPart]->Fill(pt,tof-exptimes[iS]);
 486               fNsigmaTof[iBconf][1][iS+nPart]->Fill(pt,nsigmaTOF[iS]);
 487             }
 488           }
 489         }
 490
 491       }//end kTOF available
 492     }//end track loop
 493   }//end loop on the events
 494 }
 495
 496 //_____________________________________________________________________________
 497 void AliAnalysisNucleiInfo::Terminate(Option_t *)
 498 {
 499   // Terminate loop
 500   Printf("Terminate()");
 501 }