PWGPP/TOF/AliAnalysisTaskTOFqaID.cxx

   1 /*  created by fbellini@cern.ch on 29/04/2013 */
   2 /*  last modified by fbellini   on 19/08/2013 */
   3
   4
   5 #ifndef ALIANALYSISTASKTOFQAID_CXX
   6 #define ALIANALYSISTASKTOFQAID_CXX
   7
   8 #include "TChain.h"
   9 #include "TTree.h"
  10 #include "TH1F.h"
  11 #include "TH2F.h"
  12 #include "TProfile.h"
  13 #include "TCanvas.h"
  14 #include "AliAnalysisTaskSE.h"
  15 #include "AliAnalysisManager.h"
  16 #include "AliVEvent.h"
  17 #include "AliVTrack.h"
  18 #include "AliESDEvent.h"
  19 #include "AliMCEvent.h"
  20 #include "AliMCParticle.h"
  21 #include "AliESDInputHandler.h"
  22 #include "AliMCEventHandler.h"
  23 #include "AliESDpid.h"
  24 #include "AliCDBManager.h"
  25 #include "AliTOFcalib.h"
  26 #include "AliTOFT0maker.h"
  27 #include "AliTOFT0v1.h"
  28 #include "AliAnalysisTaskTOFqaID.h"
  29 #include "AliAnalysisFilter.h"
  30 #include "AliESDtrackCuts.h"
  31 #include "AliLog.h"
  32 #include "AliTOFRawStream.h"
  33 #include "AliTOFGeometry.h"
  34
  35 ClassImp(AliAnalysisTaskTOFqaID)
  36
  37 //________________________________________________________________________
  38 AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID() :
  39   fRunNumber(0),
  40   fESD(0x0),
  41   fMCevent(0x0),
  42   fTrackFilter(0x0),
  43   fVertex(0x0),
  44   fESDpid(new AliESDpid()),
  45   fTOFT0v1(new AliTOFT0v1(fESDpid)),
  46   fTOFHeader(0x0),
  47   fEnableAdvancedCheck(kFALSE),
  48   fExpTimeBinWidth(24.4),
  49   fExpTimeRangeMin(-25010.),
  50   fExpTimeRangeMax(25010.),
  51   fExpTimeSmallRangeMin(-5002.),
  52   fExpTimeSmallRangeMax(5002.),
  53   fnExpTimeBins(1),
  54   fnExpTimeSmallBins(1),
  55   fMyTimeZeroTOF(1e20),
  56   fMyTimeZeroTOFsigma(1e20),
  57   fMyTimeZeroTOFtracks(-1),
  58   fIsMC(kFALSE),
  59   fSelectedPdg(0),
  60   fP(1e10),
  61   fPt(1e10),
  62   fEta(1e10),
  63   fPhi(1e10),
  64   fTPCOuterPhi(1e10),
  65   fL(1e10),
  66   fMatchingMomCut(1e10),
  67   fTof(1e10),
  68   fHlist(0x0),
  69   fHlistTimeZero(0x0),
  70   fHlistPID(0x0),
  71   fHlistTRD(0x0),
  72   fHlistTrigger(0x0)
  73 {
  74   // Default constructor
  75
  76    for (Int_t j=0;j<3;j++ ) {
  77      if (j<3) {
  78        fT0[j]=0.0;
  79        fNTOFtracks[j]=0;
  80      }
  81      fSigmaSpecie[j]=0.0;
  82      fTrkExpTimes[j]=0.0;
  83      fThExpTimes[j]=0.0;
  84    }
  85 }
  86 //________________________________________________________________________
  87 AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID(const char *name) :
  88   AliAnalysisTaskSE(name),
  89   fRunNumber(0),
  90   fESD(0x0),
  91   fMCevent(0x0),
  92   fTrackFilter(0x0),
  93   fVertex(0x0),
  94   fESDpid(new AliESDpid()),
  95   fTOFT0v1(new AliTOFT0v1(fESDpid)),
  96   fTOFHeader(0x0),
  97   fEnableAdvancedCheck(kFALSE),
  98   fExpTimeBinWidth(24.4),
  99   fExpTimeRangeMin(-25010.),
 100   fExpTimeRangeMax(25010.),
 101   fExpTimeSmallRangeMin(-5002.),
 102   fExpTimeSmallRangeMax(5002.),
 103   fnExpTimeBins(1),
 104   fnExpTimeSmallBins(1),
 105   fMyTimeZeroTOF(1e20),
 106   fMyTimeZeroTOFsigma(1e20),
 107   fMyTimeZeroTOFtracks(-1),
 108   fIsMC(kFALSE),
 109   fSelectedPdg(0),
 110   fP(1e10),
 111   fPt(1e10),
 112   fEta(1e10),
 113   fPhi(1e10),
 114   fTPCOuterPhi(1e10),
 115   fL(1e10),
 116   fMatchingMomCut(1.0),
 117   fTof(1e10),
 118   fHlist(0x0),
 119   fHlistTimeZero(0x0),
 120   fHlistPID(0x0),
 121   fHlistTRD(0x0),
 122   fHlistTrigger(0x0)
 123  {
 124   // Constructor
 125   // Define input and output slots here
 126    Info("AliAnalysisTaskTOFqaID","Calling Constructor");
 127
 128    for (Int_t j=0;j<5;j++ ) {
 129      if (j<3){
 130        fT0[j]=0.0;
 131        fNTOFtracks[j]=0;
 132      }
 133      fSigmaSpecie[j]=0.0;
 134      fTrkExpTimes[j]=0.0;
 135      fThExpTimes[j]=0.0;
 136    }
 137    // Input slot #0 works with a TChain
 138    DefineInput(0, TChain::Class());
 139
 140    // Output slot #0 writes into a TH1 container
 141    // Output slot #1 writes into a user defined  container
 142    DefineOutput(1, TList::Class());
 143    DefineOutput(2, TList::Class());
 144    DefineOutput(3, TList::Class());
 145    DefineOutput(4, TList::Class());
 146    DefineOutput(5, TList::Class());
 147
 148  }
 149
 150 //________________________________________________________________________
 151 AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID(const AliAnalysisTaskTOFqaID& copy)
 152 : AliAnalysisTaskSE(),
 153   fRunNumber(copy.fRunNumber),
 154   fESD(copy.fESD),
 155   fMCevent(copy.fMCevent),
 156   fTrackFilter(copy.fTrackFilter),
 157   fVertex(copy.fVertex),
 158   fESDpid(copy.fESDpid),
 159   fTOFT0v1(copy.fTOFT0v1),
 160   fTOFHeader(copy.fTOFHeader),
 161   fEnableAdvancedCheck(copy.fEnableAdvancedCheck),
 162   fExpTimeBinWidth(copy.fExpTimeBinWidth),
 163   fExpTimeRangeMin(copy.fExpTimeRangeMin),
 164   fExpTimeRangeMax(copy.fExpTimeRangeMax),
 165   fExpTimeSmallRangeMin(copy.fExpTimeSmallRangeMin),
 166   fExpTimeSmallRangeMax(copy.fExpTimeSmallRangeMax),
 167   fnExpTimeBins(copy.fnExpTimeBins),
 168   fnExpTimeSmallBins(copy.fnExpTimeSmallBins),
 169   fMyTimeZeroTOF(copy.fMyTimeZeroTOF),
 170   fMyTimeZeroTOFsigma(copy.fMyTimeZeroTOFsigma),
 171   fMyTimeZeroTOFtracks(copy.fMyTimeZeroTOFtracks),
 172   fIsMC(copy.fIsMC),
 173   fSelectedPdg(copy.fSelectedPdg),
 174   fP(copy.fP),
 175   fPt(copy.fPt),
 176   fEta(copy.fEta),
 177   fPhi(copy.fPhi),
 178   fTPCOuterPhi(copy.fTPCOuterPhi),
 179   fL(copy.fL),
 180   fMatchingMomCut(copy.fMatchingMomCut),
 181   fTof(copy.fTof),
 182   fHlist(copy.fHlist),
 183   fHlistTimeZero(copy.fHlistTimeZero),
 184   fHlistPID(copy.fHlistPID),
 185   fHlistTRD(copy.fHlistTRD),
 186   fHlistTrigger(copy.fHlistTrigger)
 187 {
 188   // Copy constructor
 189    for (Int_t j=0;j<5;j++ ) {
 190      if (j<3) {
 191        fT0[j]=copy.fT0[j];
 192        fNTOFtracks[j]=copy.fNTOFtracks[j];
 193      }
 194      fSigmaSpecie[j]=copy.fSigmaSpecie[j];
 195      fTrkExpTimes[j]=copy.fTrkExpTimes[j];
 196      fThExpTimes[j]=copy.fThExpTimes[j];
 197    }
 198
 199
 200 }
 201
 202 //___________________________________________________________________________
 203 AliAnalysisTaskTOFqaID& AliAnalysisTaskTOFqaID::operator=(const AliAnalysisTaskTOFqaID& copy)
 204 {
 205   //
 206   // Assignment operator
 207   //
 208   if (this!=&copy) {
 209     AliAnalysisTaskSE::operator=(copy) ;
 210     fRunNumber=copy.fRunNumber;
 211     fESD=copy.fESD;
 212     fMCevent=copy.fMCevent;
 213     fTrackFilter=copy.fTrackFilter;
 214     fVertex=copy.fVertex;
 215     fESDpid=copy.fESDpid;
 216     fTOFT0v1=copy.fTOFT0v1;
 217     fTOFHeader=copy.fTOFHeader;
 218     fEnableAdvancedCheck=copy.fEnableAdvancedCheck;
 219     fExpTimeBinWidth=copy.fExpTimeBinWidth;
 220     fExpTimeRangeMin=copy.fExpTimeRangeMin;
 221     fExpTimeRangeMax=copy.fExpTimeRangeMax;
 222     fExpTimeSmallRangeMin=copy.fExpTimeSmallRangeMin;
 223     fExpTimeSmallRangeMax=copy.fExpTimeSmallRangeMax;
 224     fnExpTimeBins=copy.fnExpTimeBins;
 225     fnExpTimeSmallBins=copy.fnExpTimeSmallBins;
 226     fMyTimeZeroTOF=copy.fMyTimeZeroTOF;
 227     fMyTimeZeroTOFsigma=copy.fMyTimeZeroTOFsigma;
 228     fMyTimeZeroTOFtracks=copy.fMyTimeZeroTOFtracks;
 229     for (Int_t j=0;j<5;j++ ) {
 230       if (j<3) {
 231         fT0[j]=copy.fT0[j];
 232         fNTOFtracks[j]=copy.fNTOFtracks[j];
 233       }
 234       fSigmaSpecie[j]=copy.fSigmaSpecie[j];
 235       fTrkExpTimes[j]=copy.fTrkExpTimes[j];
 236       fThExpTimes[j]=copy.fThExpTimes[j];
 237     }
 238     fIsMC=copy.fIsMC;
 239     fSelectedPdg=copy.fSelectedPdg;
 240     fP=copy.fP;
 241     fPt=copy.fPt;
 242     fEta=copy.fEta;
 243     fPhi=copy.fPhi;
 244     fTPCOuterPhi=copy.fTPCOuterPhi;
 245     fL=copy.fL;
 246     fMatchingMomCut=copy.fMatchingMomCut;
 247     fTof=copy.fTof;
 248     fHlist=copy.fHlist;
 249     fHlistTimeZero=copy.fHlistTimeZero;
 250     fHlistPID=copy.fHlistPID;
 251     fHlistTRD=copy.fHlistTRD;
 252     fHlistTrigger=copy.fHlistTrigger;
 253   }
 254   return *this;
 255 }
 256
 257 //___________________________________________________________________________
 258 AliAnalysisTaskTOFqaID::~AliAnalysisTaskTOFqaID() {
 259   //
 260   //destructor
 261   //
 262
 263   Info("~AliAnalysisTaskTOFqaID","Calling Destructor");
 264   if (fESDpid) delete fESDpid;
 265   if (fTOFHeader) delete fTOFHeader;
 266   if (fTOFT0v1) delete fTOFT0v1;
 267   if (fVertex) delete fVertex;
 268   if (fTrackFilter) delete fTrackFilter;
 269   if (AliAnalysisManager::GetAnalysisManager()->IsProofMode()) return;
 270
 271   if (fHlist) {
 272     delete fHlist;
 273     fHlist = 0;
 274   }
 275   if (fHlistTimeZero) {
 276     delete fHlistTimeZero;
 277     fHlistTimeZero = 0;
 278   }
 279   if (fHlistPID){
 280     delete fHlistPID;
 281     fHlistPID = 0;
 282   }
 283   if (fHlistTRD){
 284     delete fHlistTRD;
 285     fHlistTRD = 0;
 286   }
 287   if (fHlistTrigger){
 288     delete fHlistTrigger;
 289     fHlistTrigger = 0;
 290   }
 291 }
 292
 293 //________________________________________________________________________
 294 void AliAnalysisTaskTOFqaID::UserCreateOutputObjects()
 295 {
 296   //Defines output objects and histograms
 297   Info("CreateOutputObjects","CreateOutputObjects (TList) of task %s", GetName());
 298   OpenFile(1);
 299   if (!fHlist) fHlist = new TList();
 300   fHlist->SetOwner(kTRUE);
 301   if (!fHlistTimeZero) fHlistTimeZero = new TList();
 302   fHlistTimeZero->SetOwner(kTRUE);
 303   if (!fHlistPID) fHlistPID = new TList();
 304   fHlistPID->SetOwner(kTRUE);
 305   if (!fHlistTRD) fHlistTRD = new TList();
 306   fHlistTRD->SetOwner(kTRUE);
 307   if (!fHlistTrigger) fHlistTrigger = new TList();
 308   fHlistTrigger->SetOwner(kTRUE);
 309
 310   if (fExpTimeRangeMax<fExpTimeRangeMin) {
 311     SetExpTimeHistoRange(-25010.,25010.);
 312   }
 313   fnExpTimeBins = TMath::Nint((fExpTimeRangeMax - fExpTimeRangeMin)/fExpTimeBinWidth);//ps
 314   fExpTimeRangeMax=fExpTimeRangeMin+fnExpTimeBins*fExpTimeBinWidth;//ps
 315
 316   if (fExpTimeSmallRangeMax<fExpTimeSmallRangeMin) {
 317     SetExpTimeHistoSmallRange(-5002.,5002.);
 318   }
 319   fnExpTimeSmallBins = TMath::Nint((fExpTimeSmallRangeMax - fExpTimeSmallRangeMin)/fExpTimeBinWidth);//ps
 320   fExpTimeSmallRangeMax=fExpTimeSmallRangeMin+fnExpTimeSmallBins*fExpTimeBinWidth;//ps
 321
 322   //add plots for start time QA
 323   AddStartTimeHisto(fHlistTimeZero,"");
 324
 325   //add plots for base TOF quantities
 326   AddTofBaseHisto(fHlist,  1, "");
 327   AddTofBaseHisto(fHlist, -1, "");
 328
 329   //add plots for matching efficiency
 330   AddMatchingEffHisto(fHlist,  1, "");
 331   AddMatchingEffHisto(fHlist, -1, "");
 332
 333   //add plots for PID checks
 334   AddPidHisto(fHlistPID,  1, "");
 335   AddPidHisto(fHlistPID, -1, "");
 336
 337   //add trd plots
 338   if (fEnableAdvancedCheck) {
 339     AddTrdHisto();
 340     AddTofTrgHisto("");
 341   }
 342   PostData(1, fHlist);
 343   PostData(2, fHlistTimeZero);
 344   PostData(3, fHlistPID);
 345   PostData(4, fHlistTRD);
 346   PostData(5, fHlistTrigger);
 347 }
 348 //________________________________________________________________________
 349 void AliAnalysisTaskTOFqaID::UserExec(Option_t *)
 350 {
 351   /* Main - executed for each event.
 352     It extracts event information and track information after selecting
 353     primary tracks via standard cuts. */
 354
 355   AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 356   if (!esdH) {
 357     AliError("ERROR: Could not get ESDInputHandler");
 358     return;
 359   } else {
 360     fESD = (AliESDEvent*) esdH->GetEvent();
 361   }
 362
 363   if (!fESD) {
 364     AliError("ERROR: fESD not available");
 365     return;
 366   }
 367
 368   //access MC event handler for MC truth information
 369   if (fIsMC) {
 370     AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 371     if (!mcH) {
 372       AliError("ERROR: Could not get MCeventHandler");
 373       return;
 374     } else {
 375       fMCevent = (AliMCEvent *) mcH->MCEvent();
 376       if (!fMCevent) {
 377         AliError("Trying to retrieve an invalid MC event.");
 378         return;
 379       }
 380     }
 381   }
 382
 383   // get run number
 384   Int_t runNb = fESD->GetRunNumber();
 385   if (runNb>0) fRunNumber = runNb;
 386   //reset matched track counters
 387   for (Int_t j=0;j<3;j++){fNTOFtracks[j]=0;}
 388
 389   //Get vertex info and apply vertex cut
 390   if (!IsEventSelected(fESD)) return;
 391
 392   //set response tof_t0 for all other checks
 393   fESDpid->SetTOFResponse(fESD,AliESDpid::kTOF_T0);//(fill_t0, tof_t0, t0_t0, best_t0)
 394
 395   Printf("Momentum cut for eta and phi distributions set: Pt>%3.2f", fMatchingMomCut);
 396
 397   // loop over ESD tracks
 398   for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
 399     AliESDtrack* track = fESD->GetTrack(iTracks);
 400     if (!track) {
 401       Printf("ERROR: Could not receive track %d", iTracks);
 402       continue;
 403     }
 404
 405     //primary tracks selection: kTPCrefit and std cuts
 406     if (fTrackFilter){
 407       if(!fTrackFilter->IsSelected(track)) continue;
 408     } else {
 409       Printf("No track filter found, skipping the track loop");
 410       return;
 411     }
 412
 413     //select specie if MC
 414     if ( fIsMC &&
 415          (!SelectMCspecies(fMCevent, track))) {
 416       AliDebug(4, Form("MC tracks selection: Track=%i  label=%i  Not Accepted", iTracks, track->GetLabel()));
 417       continue;
 418     }
 419
 420     //apply cut for eta acceptance
 421     fEta=track->Eta();
 422     if (TMath::Abs(fEta)>0.8) continue;
 423
 424     //get other track variables
 425     fP = track->P();
 426     fPt = track->Pt();
 427     fPhi = track->Phi()*TMath::RadToDeg();
 428     fTPCOuterPhi = GetPhiAtTPCouterRadius(track);
 429     fL = track->GetIntegratedLength();
 430     track->GetIntegratedTimes(fTrkExpTimes);
 431
 432     Int_t charge = track->Charge();
 433
 434     FillPrimaryTrkHisto(charge,"");
 435     if (IsTPCTOFMatched(track)) {
 436       fTof=track->GetTOFsignal()*1E-3;//in ps
 437       //increment track counters
 438       fNTOFtracks[0]++;
 439       if (charge>0) fNTOFtracks[1]++;
 440       if (charge<0) fNTOFtracks[2]++;
 441       //fill histos
 442       FillTofBaseHisto(track, charge,"");
 443       FillMatchedTrkHisto(charge,"");
 444       FillPidHisto(track, charge, "");
 445     }
 446     if (fEnableAdvancedCheck) FillTrdHisto(track, charge);
 447   }//end loop on tracks
 448
 449   //fill time zero histos
 450   FillStartTimeHisto("");
 451   ((TH1F*)fHlist->FindObject("hTOFmulti_pos"))->Fill(fNTOFtracks[1]);
 452   ((TH1F*)fHlist->FindObject("hTOFmulti_neg"))->Fill(fNTOFtracks[2]);
 453
 454   //fill TOF trg histos from infos in TOF header
 455   fTOFHeader=(AliTOFHeader*)fESD->GetTOFHeader();
 456   if (!fTOFHeader) {
 457     AliWarning("Cannot get TOF header: no TOF trigger info available");
 458   } else {
 459     FillTofTrgHisto("");
 460   }
 461
 462   PostData(1, fHlist);
 463   PostData(2, fHlistTimeZero);
 464   PostData(3, fHlistPID);
 465   PostData(4, fHlistTRD);
 466   PostData(5, fHlistTrigger);
 467
 468 }
 469
 470 //________________________________________________________________________
 471 void AliAnalysisTaskTOFqaID::Terminate(Option_t *)
 472 {
 473   //check on output validity
 474   fHlist = dynamic_cast<TList*> (GetOutputData(1));
 475   if (!fHlist) {
 476     Printf("ERROR: lists not available");
 477     return;
 478   }
 479
 480   // TH1D*hDummy = ((TH1D*)fHlist->FindObject("hTOFmatchedESDPt"));
 481   // TH1D*hMatchingEff = (TH1D*) hDummy->Clone("hMatchingEff");
 482   // hMatchingEff->SetTitle("Matching efficiency");
 483   // hMatchingEff->Divide((TH1F*) fHlist->FindObject("hESDprimaryTrackPt"));
 484   // TCanvas *c1 = new TCanvas("AliAnalysisTaskTOFqaID","Matching vs Pt",10,10,510,510);
 485   // c1->cd(1)->SetLogy();
 486   // hMatchingEff->DrawCopy("E");
 487   // fHlist->AddLast(hMatchingEff);
 488   ComputeMatchingEfficiency(fHlist, "pt");
 489   ComputeMatchingEfficiency(fHlist, "eta");
 490   ComputeMatchingEfficiency(fHlist, "phi");
 491
 492   PostData(1, fHlist);
 493 }
 494
 495 //---------------------------------------------------------------
 496 Int_t AliAnalysisTaskTOFqaID::GetStripIndex(const Int_t * const in)
 497 {
 498   /* return tof strip index between 0 and 91 */
 499
 500   Int_t nStripA = AliTOFGeometry::NStripA();
 501   Int_t nStripB = AliTOFGeometry::NStripB();
 502   Int_t nStripC = AliTOFGeometry::NStripC();
 503
 504   Int_t iplate = in[1];
 505   Int_t istrip = in[2];
 506
 507   Int_t stripOffset = 0;
 508   switch (iplate) {
 509   case 0:
 510     stripOffset = 0;
 511       break;
 512   case 1:
 513     stripOffset = nStripC;
 514     break;
 515   case 2:
 516     stripOffset = nStripC+nStripB;
 517     break;
 518   case 3:
 519     stripOffset = nStripC+nStripB+nStripA;
 520     break;
 521   case 4:
 522     stripOffset = nStripC+nStripB+nStripA+nStripB;
 523     break;
 524   default:
 525     stripOffset=-1;
 526     break;
 527   };
 528
 529   if (stripOffset<0 || stripOffset>92) return -1;
 530   else
 531     return (stripOffset+istrip);
 532 }
 533
 534 //-----------------------------------------------------------------
 535 Double_t AliAnalysisTaskTOFqaID::GetPhiAtTPCouterRadius(AliESDtrack * track)
 536 {
 537   //get track phi at TPC outer radius
 538   if (!track) return 1e10;
 539   Double_t tpcoutcoord[3]={0.,0.,0.};
 540   track->GetOuterXYZ(tpcoutcoord);
 541   Double_t phiOuterTPC=TMath::ATan2(tpcoutcoord[1],tpcoutcoord[0])*TMath::RadToDeg();
 542   if (phiOuterTPC<0)
 543     phiOuterTPC+= (2*TMath::Pi()*TMath::RadToDeg());
 544   return phiOuterTPC;
 545 }
 546 //-----------------------------------------------------------------
 547 Bool_t  AliAnalysisTaskTOFqaID::IsEventSelected(AliESDEvent * event)
 548 {
 549   //select event based on primary vertex
 550   if (!event) {
 551     AliError("Invalid ESD event");
 552     return kFALSE;
 553   }
 554   fVertex = (AliESDVertex*) event->GetPrimaryVertexTracks();
 555   if(fVertex->GetNContributors()<1) {
 556     // SPD vertex
 557     fVertex = (AliESDVertex*) event->GetPrimaryVertexSPD();
 558     if(fVertex->GetNContributors()<1) fVertex = 0x0;
 559   }
 560   if (!fVertex) return kFALSE;
 561   if (TMath::Abs(fVertex->GetZv())<10.0) return kTRUE;
 562   else return kFALSE;
 563 }
 564
 565 //-----------------------------------------------------------------
 566 Bool_t  AliAnalysisTaskTOFqaID::IsTPCTOFMatched(AliESDtrack * track)
 567 {
 568   //defines TOF matching
 569   if (!track){
 570     AliWarning("Invalid track object");
 571     return kFALSE;
 572   }
 573
 574   if ( (track->IsOn(AliESDtrack::kTOFout)) &&
 575        (track->IsOn(AliESDtrack::kTIME)) &&
 576        (track->IsOn(AliESDtrack::kTPCout))  )
 577     return kTRUE;
 578   else
 579     return kFALSE;
 580 }
 581 //-----------------------------------------------------------------
 582 Bool_t  AliAnalysisTaskTOFqaID::IsInTRD(AliESDtrack * track)
 583 {
 584   //defines cut to select particles in/out TRD
 585   if (!track){
 586     AliWarning("Invalid track object");
 587     return kFALSE;
 588   }
 589
 590   if ( track->IsOn(AliESDtrack::kTPCout)
 591        && track->IsOn(AliESDtrack::kTRDout) )
 592     return kTRUE;
 593   else
 594     return kFALSE;
 595 }
 596 //-----------------------------------------------------------------
 597 void AliAnalysisTaskTOFqaID::FillStartTimeMaskHisto(TString suffix)
 598 {
 599   /* set pid response to use best_T0 and for each
 600      accepted track fills the histogram with the
 601      used start time
 602   */
 603
 604   //set response best_t0
 605   //fESDpid->SetTOFResponse(fESD,AliESDpid::kBest_T0);
 606
 607   for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
 608     AliESDtrack* track = fESD->GetTrack(iTracks);
 609     if (!track) {
 610       Printf("ERROR: Could not receive track %d", iTracks);
 611       continue;
 612     }
 613     //primary tracks selection: kTPCrefit and std cuts
 614     if (fTrackFilter){
 615       if(!fTrackFilter->IsSelected(track)) continue;
 616     }
 617     else{
 618       Printf("No track filter found, skipping the track loop");
 619       break;
 620     }
 621     if (TMath::Abs(track->Eta())>0.8) continue; //cut for acceptance
 622
 623     Int_t StartTimeBit = fESDpid->GetTOFResponse().GetStartTimeMask(track->P());
 624     ((TH2F*)fHlistTimeZero->FindObject(Form("hStartTimeMask%s",suffix.Data())))->Fill(track->P(),StartTimeBit);
 625
 626     //matched tracks selection: kTOFout and kTIME
 627     if ( (track->IsOn(AliESDtrack::kTOFout)) &&
 628          (track->IsOn(AliESDtrack::kTIME)) &&
 629          (track->IsOn(AliESDtrack::kTPCout))  ) {
 630       ((TH2F*)fHlistTimeZero->FindObject(Form("hStartTimeMaskMatched%s",suffix.Data())))->Fill(track->P(),StartTimeBit);
 631     }
 632   }
 633   return;
 634 }
 635
 636 //----------------------------------------------------
 637 Bool_t AliAnalysisTaskTOFqaID::ComputeTimeZeroByTOF1GeV()
 638 {
 639   /* compute T0-TOF for tracks within momentum range [0.95, 1.05] */
 640   /* init T0-TOF */
 641   fTOFT0v1->Init(fESD);
 642   //AliTOFT0v1 *fTOFT0v1 = new AliTOFT0v1(fESDpid);
 643   fTOFT0v1->DefineT0("all", 0.95, 1.05);
 644   fMyTimeZeroTOF = -1000. * fTOFT0v1->GetResult(0);
 645   fMyTimeZeroTOFsigma = 1000. * fTOFT0v1->GetResult(1);
 646   fMyTimeZeroTOFtracks = fTOFT0v1->GetResult(3);
 647   Bool_t hasTimeZeroTOF = kFALSE;
 648   /* check T0-TOF sigma */
 649   if (fMyTimeZeroTOFsigma < 250.)
 650     hasTimeZeroTOF = kTRUE;
 651   return hasTimeZeroTOF;
 652 }
 653
 654 //------------------------------------------------------
 655 TString AliAnalysisTaskTOFqaID::GetSpeciesName(Int_t absPdgCode)
 656 {
 657   //returns name of selected specie
 658   TString name;
 659   switch (absPdgCode){
 660   case 11:
 661     name = "electron";
 662     break;
 663   case 13:
 664     name = "muon";
 665     break;
 666   case 211:
 667     name = "pion";
 668     break;
 669   case 321:
 670     name = "kaon";
 671       break;
 672   case 2212:
 673     name = "proton";
 674     break;
 675   default:
 676     name = "noPID";
 677     break;
 678   }
 679   return name.Data();
 680 }
 681
 682 //-----------------------------------------------
 683 Bool_t AliAnalysisTaskTOFqaID::SelectMCspecies(AliMCEvent * ev, AliESDtrack * track)
 684 {
 685   //
 686   //Retrieves particle true ID from MC and selects the desired species
 687   //
 688   if ((!ev) || (!track)) {
 689     AliError("SelectMCspecies - Invalid object set as argument");
 690     return kFALSE;
 691   }
 692
 693   if (fSelectedPdg==0) return kTRUE;   //if fSelectedPdg==0, no species selection is applied
 694
 695   Long_t label = track->GetLabel();
 696   if (label<0) return kFALSE;
 697
 698   // get number of particles
 699   Long_t nMC = ev->GetNumberOfTracks();
 700   // if label too large --> failed
 701   if (label>= nMC) {
 702     AliWarning(Form("Stack overflow: track label = %li -- stack maximum = %li", label, nMC));
 703     return kFALSE;
 704   }
 705   // retrieve particle
 706   AliMCParticle *mcPart = (AliMCParticle *)ev->GetTrack(label);
 707   if (!mcPart) {// if particle = NULL --> failed
 708     AliWarning(Form("Stack discontinuity: label %li refers to a NULL object", label));
 709     return kFALSE;
 710   }
 711
 712   Int_t pdgCode = mcPart->PdgCode();
 713   if (!(TMath::Abs(pdgCode)==fSelectedPdg))
 714     return kFALSE;
 715   else  //Printf("Found particle with selected pdg code = %i", pdgCode);
 716   return  kTRUE;
 717 }
 718
 719 //----------------------------------------------------------------------------------
 720 Bool_t  AliAnalysisTaskTOFqaID::ComputeMatchingEfficiency(TList* list, TString variable)
 721 {
 722   //computes matching efficiency from previously filled histos
 723   // to be called in terminate function
 724   if (!list) return kFALSE;
 725
 726   TString matchedName, primaryName, xAxisTitle;
 727   if (variable.Contains("pt")) {
 728     matchedName = "hTOFmatchedESDPt";
 729     primaryName = "hESDprimaryTrackPt";
 730     xAxisTitle = "p_{T} (GeV/c)";
 731   }
 732   if (variable.Contains("eta")) {
 733     matchedName = "hTOFmatchedESDeta";
 734     primaryName = "hTOFprimaryESDeta";
 735     xAxisTitle = "#eta";
 736   }
 737   if (variable.Contains("phi")) {
 738     matchedName = "hTOFmatchedESDphi";
 739     primaryName = "hTOFprimaryESDphi";
 740     xAxisTitle = "#phi_vtx (deg)";
 741   }
 742   if (!list) return 0;
 743
 744   TH1D*hDummy = ((TH1D*)list->FindObject(matchedName.Data()));
 745   if (!hDummy) return 0;
 746   TH1D*hMatchingEff = (TH1D*) hDummy->Clone("hMatchingEff");
 747   hMatchingEff->SetNameTitle(Form("hMatchingEff_%s", variable.Data()),Form("Matching efficiency vs %s", variable.Data()));
 748   hMatchingEff->Divide((TH1F*) list->FindObject(primaryName.Data()));
 749   hMatchingEff->GetXaxis()->SetTitle(xAxisTitle.Data());
 750   hMatchingEff->GetYaxis()->SetRangeUser(0.0,1.0);
 751   hMatchingEff->GetYaxis()->SetTitle("#epsilon_{match}");
 752   list->AddLast(hMatchingEff);
 753   return 1;
 754 }
 755 //----------------------------------------------------------------------------------
 756 void AliAnalysisTaskTOFqaID::HistogramMakeUp(TH1* hist, Color_t color, Int_t markerStyle, TString drawOpt, TString newName, TString newTitle, TString xTitle, TString yTitle)
 757 {
 758   //set histogram style and axes style at once
 759   if (!hist) return;
 760   if (!newName.IsNull()) hist->SetName(newName.Data());
 761   if (!newTitle.IsNull()) hist->SetTitle(newTitle.Data());
 762   if (!xTitle.IsNull()) hist->GetXaxis()->SetTitle(xTitle.Data());
 763   if (!yTitle.IsNull()) hist->GetYaxis()->SetTitle(yTitle.Data());
 764   hist->SetLineColor(color);
 765   hist->SetMarkerColor(color);
 766   hist->SetMarkerStyle(markerStyle);
 767   hist->SetMarkerSize(0.7);
 768   hist->SetDrawOption(drawOpt.Data());
 769   hist->Sumw2();
 770   return;
 771 }
 772
 773 //----------------------------------------------------------------------------------
 774 void AliAnalysisTaskTOFqaID::AddTofBaseHisto(TList *list, Int_t charge, TString suffix)
 775 {
 776   //Creates histograms for monitoring TOF signal, time alignement and matching-related quantities
 777   if (!list){
 778     AliError("Invalid list passed as argument.");
 779     return;
 780   }
 781
 782   TString cLabel;
 783   if (charge<0) cLabel.Form("neg");
 784   else
 785     if (charge>0) cLabel.Form("pos");
 786     else cLabel.Form("all");
 787
 788   TH1I* hTOFmulti = new TH1I(Form("hTOFmulti%s_%s",suffix.Data(), cLabel.Data()), Form("%s matched trk per event (|#eta|#leq0.8, p_{T}#geq0.3 GeV/c)", cLabel.Data()), 100, 0, 100);
 789   HistogramMakeUp(hTOFmulti, ((charge>0)? kRed : kBlue+2), 1, "E1", "","", "N","events");
 790   list->AddLast(hTOFmulti);
 791
 792   TH1F* hTOFtime = new TH1F(Form("hTime%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk TOF signal", cLabel.Data()), 250, 0., 610. ) ;
 793   HistogramMakeUp(hTOFtime,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "t (ns)","tracks");
 794   list->AddLast(hTOFtime);
 795
 796   TH1F* hTOFrawTime = new TH1F(Form("hRawTime%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk TOF raw signal", cLabel.Data()), 250, 0., 610. ) ;
 797   HistogramMakeUp(hTOFrawTime,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "t_{raw} (ns)","tracks");
 798   list->AddLast(hTOFrawTime);
 799
 800   TH1F* hTOFtot = new TH1F(Form("hTot%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk ToT", cLabel.Data()), 50, 0., 50. ) ;
 801   HistogramMakeUp(hTOFtot,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "ToT (ns)","tracks");
 802   list->AddLast(hTOFtot);
 803
 804   TH1F* hMatchedL  = new TH1F(Form("hMatchedL%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk lenght", cLabel.Data()), 1200, -400., 800) ;
 805   HistogramMakeUp(hMatchedL,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks");
 806   list->AddLast(hMatchedL);
 807
 808   TH2F* hMatchedDxVsPt = new TH2F(Form("hMatchedDxVsPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dx vs.p_{T}", cLabel.Data()), 1000,0.,10.,200, -10., 10.) ;
 809   HistogramMakeUp(hMatchedDxVsPt,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "GeV/c (p_{T})","dx (cm)");
 810   list->AddLast(hMatchedDxVsPt);
 811
 812   TH2F* hMatchedDzVsStrip = new TH2F(Form("hMatchedDzVsStrip%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dz vs. strip (#eta)", cLabel.Data()), 92,0.,92.,200, -10., 10.) ;
 813   HistogramMakeUp(hMatchedDzVsStrip,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "strip","dz (cm)");
 814   list->AddLast(hMatchedDzVsStrip) ;
 815
 816   TProfile *hMatchedDxVsCh = new TProfile(Form("hMatchedDxVsCh%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dx vs. channel", cLabel.Data()), 157248., 0.,157248.);
 817   HistogramMakeUp(hMatchedDxVsCh,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "channel","dx (cm)");
 818   list->AddLast(hMatchedDxVsCh);
 819
 820   TProfile *hMatchedDzVsCh = new TProfile(Form("hMatchedDzVsCh%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dz vs. channel", cLabel.Data()), 157248., 0.,157248.);
 821   HistogramMakeUp(hMatchedDzVsCh,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "channel","dz (cm)");
 822   list->AddLast(hMatchedDzVsCh);
 823
 824   return;
 825 }
 826
 827 //----------------------------------------------------------------------------------
 828 void    AliAnalysisTaskTOFqaID::AddMatchingEffHisto(TList *list, Int_t charge, TString suffix)
 829 {
 830   if (!list){
 831     AliError("Invalid list passed as argument.");
 832     return;
 833   }
 834   TString cLabel;
 835   if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all");
 836
 837   TH1F* hMatchedP  = new TH1F(Form("hMatchedP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p", cLabel.Data()), 1000,0.,10.) ;
 838   HistogramMakeUp(hMatchedP,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks");
 839   list->AddLast(hMatchedP) ;
 840
 841   TH1F* hMatchedPt  = new TH1F(Form("hMatchedPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T}", cLabel.Data()), 1000,0.,10.) ;
 842   HistogramMakeUp(hMatchedPt,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "p_{T} (GeV/c)","tracks");
 843   list->AddLast(hMatchedPt) ;
 844
 845   TH1F* hMatchedEta = new TH1F(Form("hMatchedEta%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #eta", cLabel.Data()), 200, -1., 1.) ;
 846   HistogramMakeUp(hMatchedEta,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#eta","tracks");
 847   list->AddLast(hMatchedEta) ;
 848
 849   TH1F* hMatchedPhi = new TH1F(Form("hMatchedPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #phi_{vtx}", cLabel.Data()), 72, 0., 360.) ;
 850   HistogramMakeUp(hMatchedPhi,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#phi_{vtx} (deg)","tracks");
 851   list->AddLast(hMatchedPhi) ;
 852
 853   TH2F* hMatchedPtVsOutPhi  = new TH2F(Form("hMatchedPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T} vs. #phi_{TPC out}", cLabel.Data()), 72, 0.0, 360.0, 1000,0.,10.) ;
 854   HistogramMakeUp(hMatchedPtVsOutPhi,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "#phi_{TPC out} (deg)","p_{T} (GeV/c)");
 855   list->AddLast(hMatchedPtVsOutPhi) ;
 856
 857   TH1F* hPrimaryP  = new TH1F(Form("hPrimaryP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p", cLabel.Data()), 1000,0.,10.) ;
 858   HistogramMakeUp(hPrimaryP,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks");
 859   list->AddLast(hPrimaryP) ;
 860
 861   TH1F* hPrimaryPt  = new TH1F(Form("hPrimaryPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T}", cLabel.Data()), 1000,0.,10.) ;
 862   HistogramMakeUp(hPrimaryPt,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "p_{T} (GeV/c)","tracks");
 863   list->AddLast(hPrimaryPt) ;
 864
 865   TH1F* hPrimaryEta = new TH1F(Form("hPrimaryEta%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #eta", cLabel.Data()), 200, -1., 1.) ;
 866   HistogramMakeUp(hPrimaryEta,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#eta","tracks");
 867   list->AddLast(hPrimaryEta) ;
 868
 869   TH1F* hPrimaryPhi = new TH1F(Form("hPrimaryPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #phi_{vtx}", cLabel.Data()), 72, 0., 360.) ;
 870   HistogramMakeUp(hPrimaryPhi,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#phi_{vtx} (deg)","tracks");
 871   list->AddLast(hPrimaryPhi) ;
 872
 873   TH2F* hPrimaryPtVsOutPhi  = new TH2F(Form("hPrimaryPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T} vs. #phi_{TPC out}", cLabel.Data()), 72, 0.0, 360.0, 1000,0.,10.) ;
 874   HistogramMakeUp(hPrimaryPtVsOutPhi,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "#phi_{TPC out} (deg)","p_{T} (GeV/c)");
 875   list->AddLast(hPrimaryPtVsOutPhi) ;
 876   return;
 877 }
 878
 879 //----------------------------------------------------------------------------------
 880 void  AliAnalysisTaskTOFqaID::AddPidHisto(TList *list, Int_t charge, TString suffix)
 881 {
 882   //Creates histograms for monitoring TOF PID
 883   if (!list){
 884     AliError("Invalid list passed as argument.");
 885     return;
 886   }
 887   TString cLabel;
 888   if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all");
 889
 890   TH2F* hMatchedBetaVsP  = new TH2F(Form("hMatchedBetaVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #beta vs. p", cLabel.Data()), 1000, 0.0, 10.0, 150, 0., 1.5) ;
 891   HistogramMakeUp(hMatchedBetaVsP,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "p (GeV/c)","#beta");
 892   list->AddLast(hMatchedBetaVsP);
 893
 894   TH1F* hMatchedMass= new TH1F(Form("hMatchedMass%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched p.le M", cLabel.Data()), 500, 0., 5. );
 895   HistogramMakeUp(hMatchedMass,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "M (GeV/c^{2})","entries");
 896   list->AddLast(hMatchedMass);
 897
 898   TH1F* hMatchedMass2= new TH1F(Form("hMatchedMass2%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched p.le M^{2}", cLabel.Data()), 500, 0., 10. );
 899   HistogramMakeUp(hMatchedMass2,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "M^{2} (GeV^{2}/c^{4})","entries");
 900   list->AddLast(hMatchedMass2);
 901
 902   TH2F* hExpTimePiVsStrip = new TH2F(Form("hExpTimePiVsStrip%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp} vs strip",cLabel.Data()), 92, 0, 92,  fnExpTimeSmallBins, fExpTimeSmallRangeMin, fExpTimeSmallRangeMax) ;
 903   HistogramMakeUp(hExpTimePiVsStrip,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "strip (#eta)","t_{TOF}-t_{#pi,exp} [ps]");
 904   list->AddLast(hExpTimePiVsStrip);
 905
 906   TH2F* hExpTimePiT0Sub1GeV = new TH2F(Form("hExpTimePiT0Sub1GeV%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk (0.95#leq p_{T}#leq 1.05 GeV/c) t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}",cLabel.Data()), 500, 0., 500., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 907   HistogramMakeUp(hExpTimePiT0Sub1GeV,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","","n. tracks used for t_{0}^{TOF}","t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}");
 908   list->AddLast(hExpTimePiT0Sub1GeV) ;
 909
 910   TH1F* hExpTimePi = new TH1F(Form("hExpTimePi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp}",cLabel.Data()), fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 911   HistogramMakeUp(hExpTimePi,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "t_{TOF}-t_{#pi,exp} [ps]","tracks");
 912   list->AddLast(hExpTimePi);
 913
 914   TH2F* hExpTimePiVsP = new TH2F(Form("hExpTimePiVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp}",cLabel.Data()), 1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 915   HistogramMakeUp(hExpTimePiVsP,kRed+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{#pi,exp} [ps]");
 916   list->AddLast(hExpTimePiVsP);
 917
 918   TH2F* hExpTimeKaVsP = new TH2F(Form("hExpTimeKaVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{K,exp}",cLabel.Data()), 1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 919   HistogramMakeUp(hExpTimeKaVsP,kBlue+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{K,exp} [ps]");
 920   list->AddLast(hExpTimeKaVsP);
 921
 922   TH2F* hExpTimeProVsP = new TH2F(Form("hExpTimeProVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{p,exp}",cLabel.Data()),1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 923   HistogramMakeUp(hExpTimeProVsP,kGreen+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{p,exp} [ps]");
 924   list->AddLast(hExpTimeProVsP);
 925
 926   TH2F* hTOFpidSigmaPi = new TH2F(Form("hTOFpidSigmaPi%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk n#sigma^{TOF}_{#pi} vs p_{T}",cLabel.Data()), 500,0.,5.,200, -10., 10. ) ;
 927   HistogramMakeUp(hTOFpidSigmaPi,kRed+2, 1, "colz", "","", "p (GeV/c)","n#sigma_{#pi,exp} [ps]");
 928   list->AddLast(hTOFpidSigmaPi) ;
 929
 930   TH2F* hTOFpidSigmaKa = new TH2F(Form("hTOFpidSigmaKa%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk n#sigma^{TOF}_{K} vs p_{T}",cLabel.Data()), 500, 0.,5.,200, -10., 10. ) ;
 931   HistogramMakeUp(hTOFpidSigmaKa,kBlue+2, 1, "colz", "","", "p (GeV/c)","n#sigma_{K,exp} [ps]");
 932   list->AddLast(hTOFpidSigmaKa) ;
 933
 934   TH2F* hTOFpidSigmaPro = new TH2F(Form("hTOFpidSigmaPro%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk TOF n#sigma^{TOF}_{p} vs p_{T}",cLabel.Data()), 500, 0.,5.,200, -10., 10. ) ;
 935   HistogramMakeUp(hTOFpidSigmaPro,kGreen+2, 1, "colz", "","","p (GeV/c)","n#sigma_{p,exp} [ps]");
 936   list->AddLast(hTOFpidSigmaPro);
 937
 938   TH2F* hExpTimePiT0SubVsP = new TH2F(Form("hExpTimePiT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 939   HistogramMakeUp(hExpTimePiT0SubVsP,kRed+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}");
 940   list->AddLast(hExpTimePiT0SubVsP) ;
 941
 942   TH2F* hExpTimeKaT0SubVsP = new TH2F(Form("hExpTimeKaT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{K,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 943   HistogramMakeUp(hExpTimeKaT0SubVsP,kBlue+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{K,exp}-t_{0}^{TOF}");
 944   list->AddLast(hExpTimeKaT0SubVsP) ;
 945
 946   TH2F* hExpTimeProT0SubVsP = new TH2F(Form("hExpTimeProT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{p,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 947   HistogramMakeUp(hExpTimeProT0SubVsP,kGreen+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{p,exp}-t_{0}^{TOF}");
 948   list->AddLast(hExpTimeProT0SubVsP) ;
 949
 950   TH2F* hExpTimePiVsOutPhi = new TH2F(Form("hExpTimePiVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 951   HistogramMakeUp(hExpTimePiVsOutPhi,kRed+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{#pi,exp} [ps]");
 952   list->AddLast(hExpTimePiVsOutPhi);
 953
 954   TH2F* hExpTimeKaVsOutPhi = new TH2F(Form("hExpTimeKaVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{K,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 955   HistogramMakeUp(hExpTimeKaVsOutPhi,kBlue+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{K,exp} [ps]");
 956   list->AddLast(hExpTimeKaVsOutPhi);
 957
 958   TH2F* hExpTimeProVsOutPhi = new TH2F(Form("hExpTimeProVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{p,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ;
 959   HistogramMakeUp(hExpTimeProVsOutPhi,kGreen+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{p,exp} [ps]");
 960   list->AddLast(hExpTimeProVsOutPhi);
 961
 962   return;
 963 }
 964 //----------------------------------------------------------------------------------
 965 void    AliAnalysisTaskTOFqaID::AddStartTimeHisto(TList *list, TString suffix)
 966 {
 967   //Creates histograms for monitoring T0 signal and start-time related quantities
 968   if (!list){
 969     AliError("Invalid list passed as argument.");
 970     return;
 971   }
 972   TH1D* hT0AC = new TH1D(Form("hT0AC%s",suffix.Data()), "Event timeZero from T0A&C; t_{0,AC} [ps]; events", 1000, -25000., 25000. ) ;
 973   HistogramMakeUp(hT0AC, kRed+2, 20, "", "","","","");
 974   list->AddLast(hT0AC);
 975
 976   TH1D* hT0A = new TH1D(Form("hT0A%s",suffix.Data()), "Event timeZero from T0A; t_{0,A} [ps]; events", 1000, -25000., 25000. ) ;
 977   HistogramMakeUp(hT0A, kBlue+2, 25, "", "","","","");
 978   list->AddLast(hT0A);
 979
 980   TH1D* hT0C = new TH1D(Form("hT0C%s",suffix.Data()), "Event timeZero from T0C; t_{0,C} [ps]; events", 1000, -25000., 25000. ) ;
 981   HistogramMakeUp(hT0C, kGreen+2, 28, "", "","","","");
 982   list->AddLast(hT0C);
 983
 984   TH1D* hT0DetRes = new TH1D(Form("hT0DetRes%s",suffix.Data()), "T0 detector (T0A-T0C)/2; (T0A-T0C)/2 [ps]; events", 200, -500.,500. ) ;
 985   HistogramMakeUp(hT0DetRes, kMagenta+1, 1, "", "","","","");
 986   list->AddLast(hT0DetRes) ;
 987
 988   TH1F* hT0fill = new TH1F(Form("hT0fill%s",suffix.Data()), "Event timeZero of fill; t_{0,fill} [ps]; events", 1000, -25000., 25000. ) ;
 989   HistogramMakeUp(hT0fill, kOrange+1, 25, "", "","","","");
 990   list->AddLast(hT0fill) ;
 991
 992   TH1F* hT0TOF = new TH1F(Form("hT0TOF%s",suffix.Data()), "Event timeZero estimated by TOF; t0 [ps]; events", 1000, -25000., 25000. ) ;
 993   HistogramMakeUp(hT0TOF, kTeal-5, 21, "", "","","","");
 994   list->AddLast(hT0TOF) ;
 995
 996   TH1F* hT0T0 = new TH1F(Form("hT0T0%s",suffix.Data()), "Best timeZero between AC, A, C; t_{0} [ps]; events", 1000, -25000.,25000. ) ;
 997   HistogramMakeUp(hT0T0, kAzure+7, 26, "", "","","","");
 998   list->AddLast(hT0T0) ;
 999
1000   TH1F* hT0best = new TH1F(Form("hT0best%s",suffix.Data()), "Event timeZero estimated as T0best; t0 [ps]; events", 1000, -25000.,25000. ) ;
1001   HistogramMakeUp(hT0best, kBlack, 20, "", "","","","");
1002   list->AddLast(hT0best) ;
1003
1004   TH1F* hT0fillRes = new TH1F(Form("hT0fillRes%s",suffix.Data()), "Resolution of fillT0; #sigma_{fillT0} [ps];events", 250, 0.,250. ) ;
1005   HistogramMakeUp(hT0fillRes, kOrange+1, 25, "", "","","","");
1006   list->AddLast(hT0fillRes) ;
1007
1008   TH1F* hT0TOFRes = new TH1F(Form("hT0TOFRes%s",suffix.Data()), "Resolution of timeZero from TOF; #sigma_{TOFT0} [ps];events", 250, 0.,250. ) ;
1009   HistogramMakeUp(hT0TOFRes, kTeal-5, 21, "", "","","","");
1010   list->AddLast(hT0TOFRes) ;
1011
1012   TH1F* hT0T0Res = new TH1F(Form("hT0T0Res%s",suffix.Data()), "Resolution of timeZero from T0;#sigma_{T0T0}  [ps];events", 250, -0., 250. ) ;
1013   HistogramMakeUp(hT0T0Res, kAzure+7, 26, "", "","","","");
1014   list->AddLast(hT0T0Res) ;
1015
1016   TH1F* hT0bestRes = new TH1F(Form("hT0bestRes%s",suffix.Data()), "Resolution of bestT0; #sigma_{bestT0} [ps];events", 250, 0.,250. ) ;
1017   HistogramMakeUp(hT0bestRes, kBlack, 20, "", "","","","");
1018   list->AddLast(hT0bestRes) ;
1019
1020   TH2F* hT0TOFvsNtrk = new TH2F(Form("hT0TOFvsNtrk%s",suffix.Data()), "Event timeZero estimated by TOF vs. number of tracks in event;TOF-matching tracks; t0 [ps]", 100, 0., 100.,1000,-25000.,25000. ) ;
1021   HistogramMakeUp(hT0TOFvsNtrk, kTeal-5, 1, "colz", "","","","");
1022   list->AddLast(hT0TOFvsNtrk) ;
1023
1024   TH2F* hEventT0MeanVsVtx = new TH2F(Form("hEventT0MeanVsVtx%s",suffix.Data()), "T0 detector: mean vs vertex ; (t0_{A}-t0_{C})/2 [ns]; (t0_{A}+t0_{C})/2 [ns]; events", 500, -25., 25., 500, -25., 25. ) ;
1025   HistogramMakeUp(hEventT0MeanVsVtx, kBlue+2, 1, "colz", "","","","");
1026   list->AddLast(hEventT0MeanVsVtx) ;
1027
1028   TH2F* hEventV0MeanVsVtx = new TH2F(Form("hEventV0MeanVsVtx%s",suffix.Data()), "V0 detector: mean vs vertex ; (V0_{A}-V0_{C})/2 [ns]; (V0_{A}+V0_{C})/2 [ns]; events", 500, -50., 50., 500, -50., 50. ) ;
1029   HistogramMakeUp(hEventV0MeanVsVtx, kBlack, 1, "colz", "","","","");
1030   list->AddLast(hEventV0MeanVsVtx) ;
1031
1032   const Double_t startTimeMomBins[13]={ 0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.2, 1.5, 2., 3., 10.};
1033
1034   TH2F* hStartTimeMaskMatched = new TH2F(Form("hStartTimeMaskMatched%s",suffix.Data()),"Start Time Mask vs p bin for matched tracks; p(GeV/c);", 12, startTimeMomBins, 8,0.,8.);
1035   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(1,"fill_t0");
1036   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(2,"tof_t0");
1037   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(3,"T0AC");
1038   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(4,"T0AC & tof_t0");
1039   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(5,"T0A");
1040   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(6,"T0A & tof_t0");
1041   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(7,"T0C");
1042   hStartTimeMaskMatched->GetYaxis()->SetBinLabel(8,"T0C & tof_t0");
1043   HistogramMakeUp(hStartTimeMaskMatched, kRed+2, 1, "colz", "","","","");
1044   list->AddLast(hStartTimeMaskMatched);
1045
1046   TH2F* hStartTimeMask = new TH2F(Form("hStartTimeMask%s",suffix.Data()),"Start Time Mask vs p bin for primary tracks; p(GeV/c);", 12, startTimeMomBins, 8,0.,8.);
1047   hStartTimeMask->GetYaxis()->SetBinLabel(1,"fill_t0");
1048   hStartTimeMask->GetYaxis()->SetBinLabel(2,"tof_t0");
1049   hStartTimeMask->GetYaxis()->SetBinLabel(3,"T0AC");
1050   hStartTimeMask->GetYaxis()->SetBinLabel(4,"T0AC & tof_t0");
1051   hStartTimeMask->GetYaxis()->SetBinLabel(5,"T0A");
1052   hStartTimeMask->GetYaxis()->SetBinLabel(6,"T0A & tof_t0");
1053   hStartTimeMask->GetYaxis()->SetBinLabel(7,"T0C");
1054   hStartTimeMask->GetYaxis()->SetBinLabel(8,"T0C & tof_t0");
1055   HistogramMakeUp(hStartTimeMask, kRed+2, 1, "colz", "","","","");
1056   list->AddLast(hStartTimeMask);
1057
1058   return;
1059 }
1060 //----------------------------------------------------------------------------------
1061 void AliAnalysisTaskTOFqaID::AddTrdHisto()
1062 {
1063   //Creates histograms for monitoring TOF base quantities wrt TRD/no TRD selection
1064   if (!fHlistTRD){
1065     AliError("Invalid TRD list");
1066     return;
1067   }
1068
1069   AddMatchingEffHisto(fHlistTRD, 1, "_noTrd");
1070   AddMatchingEffHisto(fHlistTRD, -1, "_noTrd");
1071   AddMatchingEffHisto(fHlistTRD, 1, "_Trd");
1072   AddMatchingEffHisto(fHlistTRD, -1, "_Trd");
1073
1074   AddPidHisto(fHlistTRD, 1, "_noTrd");
1075   AddPidHisto(fHlistTRD, -1, "_noTrd");
1076   AddPidHisto(fHlistTRD, 1, "_Trd");
1077   AddPidHisto(fHlistTRD, -1, "_Trd");
1078   return;
1079 }
1080
1081
1082 //----------------------------------------------------------------------------------
1083 void AliAnalysisTaskTOFqaID::AddTofTrgHisto(TString suffix)
1084 {
1085   //defines histo with trigger info
1086   if (!fHlistTrigger){
1087     AliError("Invalid TOF trigger list");
1088     return;
1089   }
1090
1091   TH1I* hFiredMaxipad = new TH1I(Form("hFiredMaxipad%s",suffix.Data()), Form("Fired maxipad per event"), 1584, 0, 1584);
1092   HistogramMakeUp(hFiredMaxipad, kBlue+2, 1, "E1", "","", "N_{maxipad}","events");
1093   fHlistTrigger->AddLast(hFiredMaxipad);
1094
1095   TH1I* hFiredReadoutPad = new TH1I(Form("hFiredReadoutPad%s",suffix.Data()), Form("Fired readout pad per event"), 153000, 0, 153000);
1096   HistogramMakeUp(hFiredReadoutPad, kRed+2, 1, "E1", "","", "N_{pad}","events");
1097   fHlistTrigger->AddLast(hFiredReadoutPad);
1098
1099   TH1I* hFiredReadoutTrgPad = new TH1I(Form("hFiredReadoutTrgPad%s",suffix.Data()), Form("Fired readout pad in trg window"), 153000, 0, 153000);
1100   HistogramMakeUp(hFiredReadoutTrgPad, kBlack, 1, "E1", "","", "N_{pad} in trg window","events");
1101   fHlistTrigger->AddLast(hFiredReadoutTrgPad);
1102
1103   TH2I* hFiredMaxipadVsTrgPad = new TH2I(Form("hFiredMaxipadVsTrgPad%s",suffix.Data()), Form("Fired maxipad vs pads in trg window per event"), 100, 0, 100, 100, 0, 100);
1104   HistogramMakeUp(hFiredMaxipadVsTrgPad, kBlue+2, 1, "colz", "","", "N_{pad} in trg window","N_{maxipad}");
1105   fHlistTrigger->AddLast(hFiredMaxipadVsTrgPad);
1106
1107   TH2I* hTrgMap = new TH2I(Form("hTrgMap%s",suffix.Data()), Form("Map of fired maxipads"), 72, 0, 72, 22, 0, 22);
1108   HistogramMakeUp(hTrgMap, kBlue+2, 1, "colz", "","", "LTM","maxipad");
1109   fHlistTrigger->AddLast(hTrgMap);
1110
1111   return;
1112 }
1113
1114 //----------------------------------------------------------------------------------
1115 void AliAnalysisTaskTOFqaID::FillTofBaseHisto(AliESDtrack * track, Int_t charge, TString suffix)
1116 {
1117   //fill histo with TOF base quantities
1118   if (!track) return;
1119
1120   //  Double_t tofTime=track->GetTOFsignal();//in ps
1121   Double_t tofTimeRaw=track->GetTOFsignalRaw();//in ps
1122   Double_t tofToT=track->GetTOFsignalToT(); //in ps
1123   Int_t channel=track->GetTOFCalChannel();
1124   Int_t volId[5]; //(sector, plate,strip,padZ,padX)
1125   AliTOFGeometry::GetVolumeIndices(channel,volId);
1126   TString cLabel; if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all");
1127
1128   ((TH1F*)fHlist->FindObject(Form("hTime%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTof); //ns
1129   ((TH1F*)fHlist->FindObject(Form("hRawTime%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofTimeRaw*1E-3); //ns
1130   ((TH1F*)fHlist->FindObject(Form("hTot%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofToT);
1131   ((TH1F*)fHlist->FindObject(Form("hMatchedL%s_%s", suffix.Data(), cLabel.Data())))->Fill(fL);
1132   ((TH2F*)fHlist->FindObject(Form("hMatchedDxVsPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt,track->GetTOFsignalDx());
1133   ((TH2F*)fHlist->FindObject(Form("hMatchedDzVsStrip%s_%s",suffix.Data(),cLabel.Data())))->Fill((Int_t)GetStripIndex(volId),track->GetTOFsignalDz());
1134   ((TProfile*)fHlist->FindObject(Form("hMatchedDxVsCh%s_%s",suffix.Data(),cLabel.Data())))->Fill(channel,track->GetTOFsignalDx());
1135   ((TProfile*)fHlist->FindObject(Form("hMatchedDzVsCh%s_%s",suffix.Data(),cLabel.Data())))->Fill(channel,track->GetTOFsignalDz());
1136
1137   return;
1138 }
1139 //----------------------------------------------------------------------------------
1140 void AliAnalysisTaskTOFqaID::FillPrimaryTrkHisto(Int_t charge, TString suffix)
1141 {
1142   // fill histos with primary tracks info
1143   // => denominator for matching efficiency
1144   TString cLabel;
1145
1146   TList * list = new TList();
1147   if (suffix.Contains("Trd")) list = fHlistTRD;
1148   else list = fHlist;
1149
1150   if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all");
1151   ((TH1F*)list->FindObject(Form("hPrimaryP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP);
1152   ((TH1F*)list->FindObject(Form("hPrimaryPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt);
1153   if (fPt>=fMatchingMomCut) {
1154     ((TH1F*)list->FindObject(Form("hPrimaryEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta);
1155     ((TH1F*)list->FindObject(Form("hPrimaryPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi);
1156     ((TH2F*)list->FindObject(Form("hPrimaryPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt);
1157   }
1158   return;
1159 }
1160 //----------------------------------------------------------------------------------
1161 void AliAnalysisTaskTOFqaID::FillMatchedTrkHisto(Int_t charge, TString suffix)
1162 {
1163   //get matched tracks variables (matching cut to be applied externally)
1164   //=> numerator for matching efficiency
1165   TString cLabel;
1166
1167   TList * list = new TList();
1168   if (suffix.Contains("Trd")) list = fHlistTRD;
1169   else list = fHlist;
1170
1171   if (charge<0) cLabel.Form("neg");
1172   else
1173     if (charge>0) cLabel.Form("pos");
1174     else cLabel.Form("all");
1175
1176   ((TH1F*)list->FindObject(Form("hMatchedP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP);
1177   ((TH1F*)list->FindObject(Form("hMatchedPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt);
1178   if (fPt>=fMatchingMomCut) {
1179     ((TH1F*)list->FindObject(Form("hMatchedEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta);
1180     ((TH1F*)list->FindObject(Form("hMatchedPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi);
1181     ((TH2F*)list->FindObject(Form("hMatchedPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt);
1182   }
1183   return;
1184 }
1185
1186 //----------------------------------------------------------------------------------
1187 void AliAnalysisTaskTOFqaID::FillPidHisto(AliESDtrack * track, Int_t charge, TString suffix)
1188 {
1189   //basic PID performance check
1190   if (fTof<=0) {
1191     printf("WARNING: track with negative TOF time found! Skipping this track for PID checks\n");
1192     return;
1193   }
1194   if (fL<=0){
1195     printf("WARNING: track with negative length found!Skipping this track for PID checks\n");
1196     return;
1197   }
1198   if (!track) return;
1199
1200   TList * list = new TList();
1201   if (suffix.Contains("Trd")) list = fHlistTRD;
1202   else list = fHlistPID;
1203
1204   TString cLabel;
1205   if (charge<0) cLabel.Form("neg");
1206   else
1207     if (charge>0) cLabel.Form("pos");
1208     else cLabel.Form("all");
1209
1210   //calculate beta
1211   Double_t c=TMath::C()*1.E-9;// m/ns
1212   Double_t mass=0.; //GeV
1213   Double_t length=fL*0.01; // in meters
1214   Double_t tof=fTof*c;
1215   Double_t beta=length/tof;
1216   Double_t fact= (tof/length)*(tof/length) -1.;
1217   Double_t fP2 = fP*fP;
1218
1219   if(fact<=0) {
1220     mass = -fP*TMath::Sqrt(-fact);
1221   } else {
1222     mass = fP*TMath::Sqrt(fact);
1223   }
1224
1225   ((TH2F*) list->FindObject(Form("hMatchedBetaVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,beta);
1226   ((TH1F*) list->FindObject(Form("hMatchedMass%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass);
1227   ((TH1F*) list->FindObject(Form("hMatchedMass2%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass*mass);
1228
1229   //PID sigmas
1230   Bool_t isValidBeta[AliPID::kSPECIES]={0,0,0,0,0};
1231   for (Int_t specie = 0; specie < AliPID::kSPECIES; specie++){
1232     fSigmaSpecie[specie] = fESDpid->GetTOFResponse().GetExpectedSigma(fP, fTrkExpTimes[specie], AliPID::ParticleMass(specie));
1233     beta=1/TMath::Sqrt(1+AliPID::ParticleMass(specie)*AliPID::ParticleMass(specie)/(fP2));
1234     if (beta>0) {
1235       fThExpTimes[specie]=length*1.E3/(beta*c);//ps
1236       isValidBeta[specie]=kTRUE;
1237     } else {
1238       fThExpTimes[specie]=1E-10;
1239       isValidBeta[specie]=kFALSE;
1240     }
1241   }
1242   Float_t timeZeroTOF = (Float_t) fESDpid->GetTOFResponse().GetStartTime(fPt);
1243   Double_t tofps=fTof*1E3;//ps for t-texp
1244   Int_t channel=track->GetTOFCalChannel();
1245   Int_t volId[5]; //(sector, plate,strip,padZ,padX)
1246   AliTOFGeometry::GetVolumeIndices(channel,volId);
1247
1248   if (isValidBeta[AliPID::kPion]){
1249     ((TH2F*)list->FindObject(Form("hExpTimePiVsStrip%s_%s",suffix.Data(),cLabel.Data())))->Fill((Int_t)GetStripIndex(volId),tofps-fTrkExpTimes[AliPID::kPion]);//ps
1250     ((TH1F*)list->FindObject(Form("hExpTimePi%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofps-fTrkExpTimes[AliPID::kPion]);//ps
1251     ((TH2F*)list->FindObject(Form("hExpTimePiVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP, tofps-fTrkExpTimes[AliPID::kPion]);
1252     ((TH2F*)list->FindObject(Form("hTOFpidSigmaPi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt, (tofps-fTrkExpTimes[AliPID::kPion])/fSigmaSpecie[AliPID::kPion]);
1253     ((TH2F*)list->FindObject(Form("hExpTimePiT0SubVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,tofps-fTrkExpTimes[AliPID::kPion]-timeZeroTOF);
1254     ((TH2F*)list->FindObject(Form("hExpTimePiVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,tofps-fTrkExpTimes[AliPID::kPion]-timeZeroTOF);
1255
1256     if (ComputeTimeZeroByTOF1GeV()){
1257       if ((fPt>0.95)&&(fPt<1.05)){
1258         ((TH2F*)list->FindObject(Form("hExpTimePiT0Sub1GeV%s_%s",suffix.Data(),cLabel.Data())))->Fill(fMyTimeZeroTOFtracks,tofps-fMyTimeZeroTOF-fTrkExpTimes[AliPID::kPion]);
1259       }
1260     }
1261   }//end pion
1262
1263   if (isValidBeta[AliPID::kKaon]){
1264     ((TH2F*)list->FindObject(Form("hExpTimeKaVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP, tofps-fTrkExpTimes[AliPID::kKaon]);
1265     ((TH2F*)list->FindObject(Form("hTOFpidSigmaKa%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt, (tofps-fTrkExpTimes[AliPID::kKaon])/fSigmaSpecie[AliPID::kKaon]);
1266     ((TH2F*)list->FindObject(Form("hExpTimeKaT0SubVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,tofps-fTrkExpTimes[AliPID::kKaon]-timeZeroTOF);
1267     ((TH2F*)list->FindObject(Form("hExpTimeKaVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,tofps-fTrkExpTimes[AliPID::kKaon]-timeZeroTOF);
1268   }//end kaon
1269
1270   if (isValidBeta[AliPID::kProton]){
1271     ((TH2F*)list->FindObject(Form("hExpTimeProVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP, tofps-fTrkExpTimes[AliPID::kProton]);
1272     ((TH2F*)list->FindObject(Form("hTOFpidSigmaPro%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt, (tofps-fTrkExpTimes[AliPID::kProton])/fSigmaSpecie[AliPID::kProton]);
1273     ((TH2F*)list->FindObject(Form("hExpTimeProT0SubVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,tofps-fTrkExpTimes[AliPID::kProton]-timeZeroTOF);
1274     ((TH2F*)list->FindObject(Form("hExpTimeProVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,tofps-fTrkExpTimes[AliPID::kProton]-timeZeroTOF);
1275   }//end proton
1276
1277   // if (fEnableAdvancedCheck && (fPt<1.)) {
1278   //   Double_t pos[3]={0.,0.,0.};
1279   //   track->GetXYZAt(378.,5.,pos);
1280   //   if ((pos[0]==0.)&&(pos[1]==0.)&&(pos[2]==0.))continue;
1281
1282   //   Double_t phiTOF=TMath::ATan2(pos[1],pos[0])*TMath::RadToDeg();
1283   //   if (phiTOF<0) phiTOF+= (2*TMath::Pi()*TMath::RadToDeg());
1284
1285   //   //fill t-texp vs phi@TOF
1286   //    if ((phiOuterTPC<=75) || ((phiOuterTPC>=125)&&(phiOuterTPC<=235)) || (phiOuterTPC>=305) ) { //TRD sectors 2012
1287   //    if ( ((phiOuterTPC>=85)&&(phiOuterTPC<=115)) || ((phiOuterTPC>=245)&&(phiOuterTPC<=295)) ) {//no TRD sectors 2012
1288   // }
1289   return;
1290 }
1291 //----------------------------------------------------------------------------------
1292 void AliAnalysisTaskTOFqaID::FillStartTimeHisto(TString suffix)
1293 {
1294   //fill start time histo
1295   if (!fESD) {
1296     AliError("Invalid event object");
1297     return;
1298   }
1299   // info from V0 detector QA
1300   AliESDVZERO * vzero = fESD->GetVZEROData();
1301   Float_t V0Atime = vzero->GetV0ATime();
1302   Float_t V0Ctime = vzero->GetV0CTime();
1303   ((TH2F*)fHlistTimeZero->FindObject(Form("hEventV0MeanVsVtx%s",suffix.Data())))->Fill((V0Atime-V0Ctime)*0.5,(V0Atime+V0Ctime)*0.5);
1304
1305   // info from T0 detector QA
1306   for (Int_t j=0;j<3;j++){
1307     fT0[j]= (Float_t) fESD->GetT0TOF(j);//ps
1308     if (fT0[j]>90000.) fT0[j]=99999.;//fix old default values to the new one
1309   }
1310
1311   Float_t t0cut = 90000.;
1312   //Float_t t0cut =3 * t0spread; //use this cut to check t0 used in tof response
1313   // if(t0cut < 500) t0cut = 500;
1314
1315   if(TMath::Abs(fT0[1]) < t0cut && TMath::Abs(fT0[2]) < t0cut ) {
1316     //&& TMath::Abs(fT0[2]-fT0[1]) < 500)  //add this condition to check t0 used in tof response
1317     ((TH1F*)fHlistTimeZero->FindObject(Form("hT0DetRes%s",suffix.Data())))->Fill((fT0[2]-fT0[1])*0.5);
1318     ((TH1F*)fHlistTimeZero->FindObject(Form("hT0AC%s",suffix.Data())))->Fill(fT0[0]);
1319     ((TH2F*)fHlistTimeZero->FindObject(Form("hEventT0MeanVsVtx%s",suffix.Data())))->Fill((fT0[2]-fT0[1])*0.5,(fT0[2]+fT0[1])*0.5);
1320   }
1321   if(TMath::Abs(fT0[1]) < t0cut){
1322     ((TH1F*)fHlistTimeZero->FindObject(Form("hT0A%s",suffix.Data())))->Fill(fT0[1]);
1323   }
1324   if(TMath::Abs(fT0[2]) < t0cut){
1325     ((TH1F*)fHlistTimeZero->FindObject(Form("hT0C%s",suffix.Data())))->Fill(fT0[2]);
1326   }
1327
1328   //  event timeZero QA via AliESDpid::SetTOFResponse()
1329   Double_t timeZero[4]={99999.,99999.,99999.,99999.};
1330   Double_t timeZeroRes[4]={99999.,99999.,99999.,99999.};
1331
1332   TString timeZeroHisto[4]={"hT0fill","hT0TOF","hT0T0","hT0best"};
1333   TString timeZeroHistoRes[4]={"hT0fillRes","hT0TOFRes","hT0T0Res","hT0bestRes"};
1334   for (Int_t j=0;j<4;j++){
1335     timeZeroHisto[j].Append(suffix.Data());
1336     timeZeroHistoRes[j].Append(suffix.Data());
1337     fESDpid->SetTOFResponse(fESD, (AliESDpid::EStartTimeType_t) j);//(fill_t0, tof_t0, t0_t0, best_t0)
1338     timeZero[j]=fESDpid->GetTOFResponse().GetStartTime(10.); //timeZero for bin pT>10GeV/c
1339     timeZeroRes[j]=fESDpid->GetTOFResponse().GetStartTimeRes(10.); //timeZero for bin pT>10GeV/c
1340     ((TH1D*)(fHlistTimeZero->FindObject(timeZeroHisto[j].Data())))->Fill(timeZero[j]);
1341     ((TH1D*)(fHlistTimeZero->FindObject(timeZeroHistoRes[j].Data())))->Fill(timeZeroRes[j]);
1342   }
1343   ((TH2F*)fHlistTimeZero->FindObject("hT0TOFvsNtrk"))->Fill(fNTOFtracks[0],timeZero[AliESDpid::kTOF_T0]);
1344
1345   //response set to best_t0 by previous loop
1346   FillStartTimeMaskHisto(suffix.Data());
1347
1348   return;
1349 }
1350 //----------------------------------------------------------------------------------
1351 void AliAnalysisTaskTOFqaID::FillTrdHisto(AliESDtrack * track, Int_t charge)
1352 {
1353   //fill histograms for TRD/noTRD
1354   if (!track){
1355     AliError("Invalid track object");
1356     return;
1357   }
1358
1359   if (IsInTRD(track)){
1360     FillPrimaryTrkHisto(charge,"_Trd");
1361     if (IsTPCTOFMatched(track)) {
1362       FillMatchedTrkHisto(charge,"_Trd");
1363       FillPidHisto(track,charge, "_Trd");
1364     }
1365   } else {
1366     FillPrimaryTrkHisto(charge,"_noTrd");
1367     if (IsTPCTOFMatched(track)) {
1368       FillMatchedTrkHisto(charge,"_noTrd");
1369       FillPidHisto(track, charge, "_noTrd");
1370     }
1371   }
1372   return;
1373 }
1374 //----------------------------------------------------------------------------------
1375 void AliAnalysisTaskTOFqaID::FillTofTrgHisto(TString suffix)
1376 {
1377   //fills histo with trigger info
1378   if (!fHlistTrigger){
1379     AliError("Invalid TOF trigger list");
1380     return;
1381   }
1382   if (!fTOFHeader) {
1383     AliWarning("Invalid AliTOFHeader object - cannot fill trg histo");
1384     return;
1385   }
1386
1387   Int_t nPad = fTOFHeader->GetNumberOfTOFclusters(); // tutti i pad di readout che hanno sparato
1388   Int_t nTrgPad = fTOFHeader->GetNumberOfTOFtrgPads();//i pad di readout che hanno sparato nella finesta di trigger
1389   Int_t nMaxiPad = fTOFHeader->GetNumberOfTOFmaxipad(); // numero di maxipad che hanno sparato
1390
1391   // aggiornare un histo con le mappe di maxipad che hanno sparato
1392   AliTOFTriggerMask *trgMask = fTOFHeader->GetTriggerMask();
1393   for(Int_t j=0;j<72;j++){
1394     for(Int_t i=22;i>=0;i--){
1395       if(trgMask->IsON(j,i))
1396         ((TH1I*)fHlistTrigger->FindObject(Form("hTrgMap%s",suffix.Data())))->Fill(j+1,i+1);
1397     }
1398   }
1399   ((TH1I*)fHlistTrigger->FindObject(Form("hFiredMaxipad%s",suffix.Data())))->Fill(nMaxiPad);
1400   ((TH1I*)fHlistTrigger->FindObject(Form("hFiredReadoutPad%s",suffix.Data())))->Fill(nPad);
1401   ((TH1I*)fHlistTrigger->FindObject(Form("hFiredReadoutTrgPad%s",suffix.Data())))->Fill(nTrgPad);
1402   ((TH2I*)fHlistTrigger->FindObject(Form("hFiredMaxipadVsTrgPad%s",suffix.Data())))->Fill(nTrgPad,nMaxiPad);
1403
1404   return;
1405 }
1406
1407 #endif